LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: killwing[P]PTree/./PTree.cpp
// Function: PTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Path::Path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
PTree<Key>::Path::Path(const std::string& path) {
    std::string::size_type start = 0;
    while (start < path.size()) {
        std::string::size_type pos = path.find(".", start);
        if (pos == std::string::npos) {
            pos = path.size();
        }
        p_.push(path.substr(start, pos - start));
        start = pos + 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xa760
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0xa872
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3a52(%rip), %rsi      # 0xe237
callq 0x33a0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0xa802
movq -0x10(%rbp), %rdi
callq 0x3160
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
subq %rdx, %rcx
leaq -0x40(%rbp), %rdi
callq 0x3220
jmp 0xa824
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xa990
jmp 0xa833
leaq -0x40(%rbp), %rdi
callq 0x3120
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa7b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa878
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3120
jmp 0xa878
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6560
movq -0x48(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/genpattern.cpp
// Function: qrmload(int, int)
int qrmload(int c,int jo){
    char chr;FILE *fp;
    long long int qsize = std::filesystem::file_size(fname);
    fp = fopen(fname, "r"); // open file or return null
    if(fp == NULL) {
        printf("%s doesn't exist!\n", fname);
        exit(2);return -1;}
    int rlen = rand()%(qsize-c);
    fseek(fp,rlen,SEEK_SET);
    for(int i=0;i<c;i++) {
        chr = fgetc(fp);
        ptlist[jo][i] = chr;
        if(chr<0){ptlist[jo][i]=chr + 256;}}
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x2e23(%rip), %rsi      # 0x4158
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x2, %edx
callq 0x1a60
movq -0x70(%rbp), %rdi
callq 0x1170
movq %rax, -0x68(%rbp)
jmp 0x1356
leaq -0x48(%rbp), %rdi
callq 0x1b40
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x2dea(%rip), %rdi      # 0x4158
leaq 0xc8f(%rip), %rsi       # 0x2004
callq 0x1140
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13be
movq 0x2dcc(%rip), %rsi      # 0x4158
leaq 0xc73(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1030
movl $0x2, %edi
callq 0x1150
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1b40
jmp 0x1462
callq 0x1060
cltq
movq -0x20(%rbp), %rcx
movslq -0x4(%rbp), %rdx
subq %rdx, %rcx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x1130
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x145a
movq -0x18(%rbp), %rdi
callq 0x11b0
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %dl
movslq -0x8(%rbp), %rcx
leaq 0x2d5e(%rip), %rax      # 0x4170
imulq $0x64, %rcx, %rcx
addq %rcx, %rax
movslq -0x5c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jge 0x144d
movsbl -0x9(%rbp), %eax
addl $0x100, %eax            # imm = 0x100
movb %al, %dl
movslq -0x8(%rbp), %rcx
leaq 0x2d31(%rip), %rax      # 0x4170
imulq $0x64, %rcx, %rcx
addq %rcx, %rax
movslq -0x5c(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x144f
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x13f0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x11c0
nopl (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/genpattern.cpp
// Function: shelp()
int shelp(){
    printf("--Simple Usage------------------\n");
    printf("\nRead <inputfile> and make <queryfile>. \n");
    printf(": ./genpattern -i <inputfile>\n");
    printf("\nYou can set the name of output by using option -o. \n");
    printf(": ./genpattern -i <inputfile> -o <outputfile>\n");
    printf("\nYou can set the number of query by using option -r. \n");
    printf("10 is used by default.(defined 'MREP' in this code.)\n");
    printf(": ./genpattern -i <inputfile> -o <outputfile> -r <times>\n");
    printf("\nYou can set the length of pattern by using option -l. \n");
    printf("100 is used by default.(defined 'MLONG' in this code.)\n");
    printf(": ./genpattern -i <inputfile> -o <outputfile> -l <length>\n");
    printf("\n");
    printf("\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb9e(%rip), %rdi       # 0x2019
movb $0x0, %al
callq 0x1030
leaq 0xbb2(%rip), %rdi       # 0x203b
movb $0x0, %al
callq 0x1030
leaq 0xbce(%rip), %rdi       # 0x2065
movb $0x0, %al
callq 0x1030
leaq 0xbdf(%rip), %rdi       # 0x2084
movb $0x0, %al
callq 0x1030
leaq 0xc07(%rip), %rdi       # 0x20ba
movb $0x0, %al
callq 0x1030
leaq 0xc28(%rip), %rdi       # 0x20e9
movb $0x0, %al
callq 0x1030
leaq 0xc51(%rip), %rdi       # 0x2120
movb $0x0, %al
callq 0x1030
leaq 0xc79(%rip), %rdi       # 0x2156
movb $0x0, %al
callq 0x1030
leaq 0xca5(%rip), %rdi       # 0x2190
movb $0x0, %al
callq 0x1030
leaq 0xcd0(%rip), %rdi       # 0x21c9
movb $0x0, %al
callq 0x1030
leaq 0xcfa(%rip), %rdi       # 0x2201
movb $0x0, %al
callq 0x1030
leaq 0xb4e(%rip), %rdi       # 0x2063
movb $0x0, %al
callq 0x1030
leaq 0xb40(%rip), %rdi       # 0x2063
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/moveHP.cc
// Function: main
int main()
{
	HasPtr hp("hi mom");
	HasPtr hp2(hp);
	// HasPtr hp2 = std::move(hp);
	std::cout << "===========" << std::endl;
	hp = hp2; // hp2 is an lvalue; copy constructor used to copy hp2
	std::cout << "===========" << std::endl;
	hp = std::move(hp2); // move constructor moves hp2
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1100
movq -0x80(%rbp), %rdx
leaq 0xd91(%rip), %rsi       # 0x2004
leaq -0x30(%rbp), %rdi
callq 0x10d0
jmp 0x127e
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1420
jmp 0x128d
leaq -0x30(%rbp), %rdi
callq 0x1060
leaq -0x31(%rbp), %rdi
callq 0x10c0
leaq -0x58(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x14c0
jmp 0x12ae
movq 0x2d23(%rip), %rdi      # 0x3fd8
leaq 0xd4f(%rip), %rsi       # 0x200b
callq 0x1080
movq %rax, -0x88(%rbp)
jmp 0x12ca
movq -0x88(%rbp), %rdi
movq 0x2cf0(%rip), %rsi      # 0x3fc8
callq 0x10b0
jmp 0x12df
leaq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x14c0
jmp 0x12ee
leaq -0x10(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1570
jmp 0x12fd
leaq -0x68(%rbp), %rdi
callq 0x15d0
movq 0x2ccb(%rip), %rdi      # 0x3fd8
leaq 0xcf7(%rip), %rsi       # 0x200b
callq 0x1080
movq %rax, -0x90(%rbp)
jmp 0x1322
movq -0x90(%rbp), %rdi
movq 0x2c98(%rip), %rsi      # 0x3fc8
callq 0x10b0
jmp 0x1337
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x1610
movq -0x98(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x1570
jmp 0x135d
leaq -0x78(%rbp), %rdi
callq 0x15d0
leaq -0x58(%rbp), %rdi
callq 0x15d0
leaq -0x10(%rbp), %rdi
callq 0x15d0
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x13a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1060
leaq -0x31(%rbp), %rdi
callq 0x10c0
jmp 0x140b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1402
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x13f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x15d0
jmp 0x13f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x15d0
leaq -0x58(%rbp), %rdi
callq 0x15d0
leaq -0x10(%rbp), %rdi
callq 0x15d0
movq -0x40(%rbp), %rdi
callq 0x10f0
nopw %cs:(%rax,%rax)
nop
// File: amadvance[P]tommyds/check.c
// Function: compare
int compare(const void* void_a, const void* void_b)
{
	const struct object* a = void_a;
	const struct object* b = void_b;

	++compare_counter;

	if (a->value < b->value)
		return -1;
	if (a->value > b->value)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0xdc0e(%rip), %eax      # 0xedf0
addl $0x1, %eax
movl %eax, 0xdc05(%rip)      # 0xedf0
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1202
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1220
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x1219
movl $0x1, -0x4(%rbp)
jmp 0x1220
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/check.c
// Function: compare_vector
int compare_vector(const void* void_a, const void* void_b)
{
	const struct object_vector* a = void_a;
	const struct object_vector* b = void_b;

	++compare_counter;

	if (a->value < b->value)
		return -1;
	if (a->value > b->value)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0xdb9e(%rip), %eax      # 0xedf0
addl $0x1, %eax
movl %eax, 0xdb95(%rip)      # 0xedf0
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1272
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1290
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x1289
movl $0x1, -0x4(%rbp)
jmp 0x1290
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/check.c
// Function: rnd
unsigned rnd(unsigned max) 
{
	unsigned r;
	tommy_uint64_t divider;
    
loop:    
	/* linear congruential generator from MMIX by Donald Knuth, http://en.wikipedia.org/wiki/Linear_congruential_generator */
#ifdef _MSC_VER
	divider = 0xFFFFFFFFFFFFFFFF / max;
	SEED = SEED * 6364136223846793005 + 1442695040888963407;
#else
	divider = 0xFFFFFFFFFFFFFFFFULL / max;
	SEED = SEED * 6364136223846793005LL + 1442695040888963407LL;
#endif
 
	r = (unsigned)(SEED / divider);

	/* it may happen as the divider is approximated down */
	if (r >= max)
		/* LCOV_EXCL_START */
		goto loop;
		/* LCOV_EXCL_STOP */

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movabsq $0x5851f42d4c957f2d, %rax # imm = 0x5851F42D4C957F2D
imulq 0xdb2a(%rip), %rax      # 0xedf8
movabsq $0x14057b7ef767814f, %rcx # imm = 0x14057B7EF767814F
addq %rcx, %rax
movq %rax, 0xdb16(%rip)      # 0xedf8
movq 0xdb0f(%rip), %rax      # 0xedf8
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jb 0x12fe
jmp 0x12a7
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/check.c
// Function: isqrt
unsigned isqrt(unsigned n)
{
	unsigned root, remain, place;

	root = 0;

	remain = n;

	place = 0x40000000;

	while (place > remain)
		place /= 4;

	while (place) {
		if (remain >= root + place) {
			remain -= root + place;
			root += 2 * place;
		}

		root /= 2;
		place /= 4;
	}

	return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x40000000, -0x10(%rbp) # imm = 0x40000000
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x133e
movl -0x10(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x132b
jmp 0x1340
cmpl $0x0, -0x10(%rbp)
je 0x137f
movl -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jb 0x136c
movl -0x8(%rbp), %ecx
addl -0x10(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
shll %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x1340
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/check.c
// Function: start
void start(const char* str)
{
	cache_clear();
	compare_counter = 0;
	the_str = str;
	the_start = nano();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1390
movl $0x0, 0xd9f5(%rip)      # 0xedf0
movq -0x8(%rbp), %rax
movq %rax, 0x100d9fa(%rip)   # 0x100ee00
callq 0x1420
movq %rax, 0x100d9f6(%rip)   # 0x100ee08
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: amadvance[P]tommyds/./tommyds/tommyhash.h
// Function: tommy_inthash_u32
tommy_inline tommy_uint32_t tommy_inthash_u32(tommy_uint32_t key)
{
	key -= key << 6;
	key ^= key >> 17;
	key -= key << 9;
	key ^= key << 4;
	key -= key << 3;
	key ^= key << 10;
	key ^= key >> 15;

	return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shll $0x6, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x11, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shll $0x9, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0x4, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shll $0x3, %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0xa, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0xf, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/./tommyds/tommyhash.h
// Function: tommy_inthash_u64
tommy_inline tommy_uint64_t tommy_inthash_u64(tommy_uint64_t key)
{
	key = ~key + (key << 21);
	key = key ^ (key >> 24);
	key = key + (key << 3) + (key << 8);
	key = key ^ (key >> 14);
	key = key + (key << 2) + (key << 4);
	key = key ^ (key >> 28);
	key = key + (key << 31);

	return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorq $-0x1, %rax
movq -0x8(%rbp), %rcx
shlq $0x15, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x18, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0xe, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x1c, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shlq $0x1f, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x989680, -0x4(%rbp)   # imm = 0x989680
movl $0x4c4b400, %edi        # imm = 0x4C4B400
callq 0x10b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x55d0
cmpq $0x8, -0x18(%rbp)
jae 0x197c
callq 0x1040
leaq -0x30(%rbp), %rdi
callq 0x5670
leaq -0x30(%rbp), %rdi
movl $0x7, %esi
movl $0x8, %edx
callq 0x55d0
cmpq $0x8, -0x20(%rbp)
je 0x19a4
callq 0x1040
leaq -0x30(%rbp), %rdi
callq 0x5670
leaq -0x30(%rbp), %rdi
movl $0x1f400, %esi          # imm = 0x1F400
movl $0x40, %edx
callq 0x55d0
leaq -0x30(%rbp), %rdi
callq 0x5700
cmpq $0x0, %rax
jne 0x19d4
callq 0x1040
leaq -0x30(%rbp), %rdi
callq 0x5670
leaq -0x30(%rbp), %rdi
movl $0x40, %edx
movq %rdx, %rsi
callq 0x55d0
leaq 0x8785(%rip), %rdi      # 0xa17a
callq 0x13e0
movl $0x0, -0x8(%rbp)
cmpl $0x989680, -0x8(%rbp)   # imm = 0x989680
jae 0x1a2c
leaq -0x30(%rbp), %rdi
callq 0x5700
movq %rax, %rdx
movq -0x38(%rbp), %rax
movl -0x8(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1a01
callq 0x1460
leaq 0x8748(%rip), %rdi      # 0xa180
callq 0x13e0
movl $0x0, -0x8(%rbp)
cmpl $0x989680, -0x8(%rbp)   # imm = 0x989680
jae 0x1a6c
movq -0x38(%rbp), %rax
movl -0x8(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5870
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1a44
callq 0x1460
leaq -0x30(%rbp), %rdi
callq 0x5670
movq -0x38(%rbp), %rdi
callq 0x1030
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: amadvance[P]tommyds/check.c
// Function: test_list_order
void test_list_order(tommy_node* list)
{
	tommy_node* node;

	node = list;
	while (node) {
		if (node->next) {
			const struct object* a = node->data;
			const struct object* b = node->next->data;
			/* check order */
			if (a->value > b->value)
				/* LCOV_EXCL_START */
				abort();
				/* LCOV_EXCL_STOP */
			/* check order for stable sort */
			if (a->value == b->value && a > b)
				/* LCOV_EXCL_START */
				abort();
				/* LCOV_EXCL_STOP */
		}
		node = node->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1b0f
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1b02
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x1ae3
callq 0x1040
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1b00
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x1b00
callq 0x1040
jmp 0x1b02
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1aa4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amadvance[P]tommyds/./tommyds/tommylist.h
// Function: tommy_list_tail
tommy_inline tommy_node* tommy_list_tail(tommy_list* list)
{
	tommy_node* head = tommy_list_head(list);

	if (!head)
		return 0;

	return head->prev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x20ca
movq $0x0, -0x8(%rbp)
jmp 0x20d6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movl $0x2faf080, -0x224(%rbp) # imm = 0x2FAF080
leaq -0x218(%rbp), %rdi
callq 0x58d0
leaq -0x218(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x59e0
leaq 0x7b25(%rip), %rdi      # 0xa1ed
callq 0x13e0
movq $0x0, -0x220(%rbp)
cmpq $0x2faf080, -0x220(%rbp) # imm = 0x2FAF080
jae 0x2730
movq -0x220(%rbp), %rsi
addq $0x1, %rsi
leaq -0x218(%rbp), %rdi
callq 0x59e0
movq -0x220(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x2820
cmpq $0x0, %rax
je 0x271a
callq 0x1040
jmp 0x271c
movq -0x220(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x220(%rbp)
jmp 0x26d8
callq 0x1460
leaq 0x7abc(%rip), %rdi      # 0xa1f8
callq 0x13e0
movq $0x0, -0x220(%rbp)
cmpq $0x2faf080, -0x220(%rbp) # imm = 0x2FAF080
jae 0x2787
movq -0x220(%rbp), %rsi
movq -0x220(%rbp), %rdx
leaq -0x218(%rbp), %rdi
callq 0x2850
movq -0x220(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x220(%rbp)
jmp 0x274c
callq 0x1460
leaq 0x7a6f(%rip), %rdi      # 0xa202
callq 0x13e0
movq $0x0, -0x220(%rbp)
cmpq $0x2faf080, -0x220(%rbp) # imm = 0x2FAF080
jae 0x27ea
movq -0x220(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x2820
movq -0x220(%rbp), %rcx
cmpq %rcx, %rax
je 0x27d4
callq 0x1040
jmp 0x27d6
movq -0x220(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x220(%rbp)
jmp 0x27a3
callq 0x1460
leaq -0x218(%rbp), %rdi
callq 0x5ab0
cmpq $0x17d78400, %rax       # imm = 0x17D78400
jae 0x2808
callq 0x1040
leaq -0x218(%rbp), %rdi
callq 0x5970
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl $0x2faf080, -0x228(%rbp) # imm = 0x2FAF080
leaq -0x220(%rbp), %rdi
movl $0x4, %esi
callq 0x5ad0
leaq -0x220(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5c10
leaq 0x793f(%rip), %rdi      # 0xa20c
callq 0x13e0
movl $0x0, -0x224(%rbp)
cmpl $0x2faf080, -0x224(%rbp) # imm = 0x2FAF080
jae 0x2940
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x220(%rbp), %rdi
callq 0x5c10
movl -0x224(%rbp), %eax
movl %eax, %esi
leaq -0x220(%rbp), %rdi
callq 0x2a40
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
cmpl $0x0, (%rax)
je 0x292d
callq 0x1040
jmp 0x292f
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x224(%rbp)
jmp 0x28dc
callq 0x1460
leaq 0x78cd(%rip), %rdi      # 0xa219
callq 0x13e0
movl $0x0, -0x224(%rbp)
cmpl $0x2faf080, -0x224(%rbp) # imm = 0x2FAF080
jae 0x29a2
movl -0x224(%rbp), %eax
movl %eax, %esi
leaq -0x220(%rbp), %rdi
callq 0x2a40
movq %rax, -0x238(%rbp)
movl -0x224(%rbp), %ecx
movq -0x238(%rbp), %rax
movl %ecx, (%rax)
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x224(%rbp)
jmp 0x295b
callq 0x1460
leaq 0x7877(%rip), %rdi      # 0xa225
callq 0x13e0
movl $0x0, -0x224(%rbp)
cmpl $0x2faf080, -0x224(%rbp) # imm = 0x2FAF080
jae 0x2a0d
movl -0x224(%rbp), %eax
movl %eax, %esi
leaq -0x220(%rbp), %rdi
callq 0x2a40
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rax
movl (%rax), %eax
cmpl -0x224(%rbp), %eax
je 0x29fa
callq 0x1040
jmp 0x29fc
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x224(%rbp)
jmp 0x29bd
callq 0x1460
leaq -0x220(%rbp), %rdi
callq 0x5cf0
cmpq $0xbebc200, %rax        # imm = 0xBEBC200
jae 0x2a2b
callq 0x1040
leaq -0x220(%rbp), %rdi
callq 0x5b90
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x210(%rcx), %rax
jae 0x2a63
jmp 0x2a82
leaq 0x78a1(%rip), %rdi      # 0xa30b
leaq 0x78f8(%rip), %rsi      # 0xa369
movl $0x60, %edx
leaq 0x7905(%rip), %rcx      # 0xa382
callq 0x1080
movq -0x10(%rbp), %rdi
orq $0x1, %rdi
callq 0x4950
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x200(%rdx), %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movl $0x2faf080, -0x22c(%rbp) # imm = 0x2FAF080
leaq -0x220(%rbp), %rdi
callq 0x5d20
leaq -0x220(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5e10
leaq 0x7739(%rip), %rdi      # 0xa231
callq 0x13e0
movq $0x0, -0x228(%rbp)
cmpq $0x2faf080, -0x228(%rbp) # imm = 0x2FAF080
jae 0x2b60
movq -0x228(%rbp), %rsi
addq $0x1, %rsi
leaq -0x220(%rbp), %rdi
callq 0x5e10
movq -0x228(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x2c50
cmpq $0x0, %rax
je 0x2b4a
callq 0x1040
jmp 0x2b4c
movq -0x228(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x228(%rbp)
jmp 0x2b08
callq 0x1460
leaq 0x76d3(%rip), %rdi      # 0xa23f
callq 0x13e0
movq $0x0, -0x228(%rbp)
cmpq $0x2faf080, -0x228(%rbp) # imm = 0x2FAF080
jae 0x2bb7
movq -0x228(%rbp), %rsi
movq -0x228(%rbp), %rdx
leaq -0x220(%rbp), %rdi
callq 0x2c80
movq -0x228(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x228(%rbp)
jmp 0x2b7c
callq 0x1460
leaq 0x7689(%rip), %rdi      # 0xa24c
callq 0x13e0
movq $0x0, -0x228(%rbp)
cmpq $0x2faf080, -0x228(%rbp) # imm = 0x2FAF080
jae 0x2c1a
movq -0x228(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x2c50
movq -0x228(%rbp), %rcx
cmpq %rcx, %rax
je 0x2c04
callq 0x1040
jmp 0x2c06
movq -0x228(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x228(%rbp)
jmp 0x2bd3
callq 0x1460
leaq -0x220(%rbp), %rdi
callq 0x5f10
cmpq $0x17d78400, %rax       # imm = 0x17D78400
jae 0x2c38
callq 0x1040
leaq -0x220(%rbp), %rdi
callq 0x5d50
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movl $0x2faf080, -0x230(%rbp) # imm = 0x2FAF080
leaq -0x228(%rbp), %rdi
movl $0x4, %esi
callq 0x5f50
leaq -0x228(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6000
leaq 0x755c(%rip), %rdi      # 0xa259
callq 0x13e0
movl $0x0, -0x22c(%rbp)
cmpl $0x2faf080, -0x22c(%rbp) # imm = 0x2FAF080
jae 0x2d70
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x228(%rbp), %rdi
callq 0x6000
movl -0x22c(%rbp), %eax
movl %eax, %esi
leaq -0x228(%rbp), %rdi
callq 0x2e70
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d5d
callq 0x1040
jmp 0x2d5f
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0x2d0c
callq 0x1460
leaq 0x74ed(%rip), %rdi      # 0xa269
callq 0x13e0
movl $0x0, -0x22c(%rbp)
cmpl $0x2faf080, -0x22c(%rbp) # imm = 0x2FAF080
jae 0x2dd2
movl -0x22c(%rbp), %eax
movl %eax, %esi
leaq -0x228(%rbp), %rdi
callq 0x2e70
movq %rax, -0x240(%rbp)
movl -0x22c(%rbp), %ecx
movq -0x240(%rbp), %rax
movl %ecx, (%rax)
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0x2d8b
callq 0x1460
leaq 0x749a(%rip), %rdi      # 0xa278
callq 0x13e0
movl $0x0, -0x22c(%rbp)
cmpl $0x2faf080, -0x22c(%rbp) # imm = 0x2FAF080
jae 0x2e3d
movl -0x22c(%rbp), %eax
movl %eax, %esi
leaq -0x228(%rbp), %rdi
callq 0x2e70
movq %rax, -0x248(%rbp)
movq -0x248(%rbp), %rax
movl (%rax), %eax
cmpl -0x22c(%rbp), %eax
je 0x2e2a
callq 0x1040
jmp 0x2e2c
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0x2ded
callq 0x1460
leaq -0x228(%rbp), %rdi
callq 0x60c0
cmpq $0xbebc200, %rax        # imm = 0xBEBC200
jae 0x2e5b
callq 0x1040
leaq -0x228(%rbp), %rdi
callq 0x5f90
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
// File: amadvance[P]tommyds/./tommyds/tommytrieinp.h
// Function: tommy_trie_inplace_search
tommy_inline void* tommy_trie_inplace_search(tommy_trie_inplace* trie_inplace, tommy_key_t key)
{
	tommy_trie_inplace_node* i = tommy_trie_inplace_bucket(trie_inplace, key);

	if (!i)
		return 0;

	return i->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7800
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x47b2
movq $0x0, -0x8(%rbp)
jmp 0x47be
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: amadvance[P]tommyds/check.c
// Function: main
int main() {
	nano_init();

	printf("Tommy check program.\n");

	test_hash();
	test_alloc();
	test_list();
	test_tree();
	test_array();
	test_arrayof();
	test_arrayblk();
	test_arrayblkof();
	test_hashtable();
	test_hashdyn();
	test_hashlin();
	test_trie();
	test_trie_inplace();

	printf("OK\n");

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x4850
leaq 0x5b06(%rip), %rdi      # 0xa2f1
movb $0x0, %al
callq 0x1070
callq 0x14b0
callq 0x1940
callq 0x1b20
callq 0x2160
callq 0x2690
callq 0x2890
callq 0x2ac0
callq 0x2cc0
callq 0x2ef0
callq 0x33c0
callq 0x3830
callq 0x3f10
callq 0x43b0
leaq 0x5acd(%rip), %rdi      # 0xa307
movb $0x0, %al
callq 0x1070
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: amadvance[P]tommyds/./tommyds/tommyhashlin.h
// Function: tommy_hashlin_bucket_ref
tommy_inline tommy_hashlin_node** tommy_hashlin_bucket_ref(tommy_hashlin* hashlin, tommy_hash_t hash)
{
	tommy_size_t pos;
	tommy_size_t high_pos;

	pos = hash & hashlin->low_mask;
	high_pos = hash & hashlin->bucket_mask;

	/* if this position is already allocated in the high half */
	if (pos < hashlin->split) {
		/* The following assigment is expected to be implemented */
		/* with a conditional move instruction */
		/* that results in a little better and constant performance */
		/* regardless of the split position. */
		/* This affects mostly the worst case, when the split value */
		/* is near at its half, resulting in a totally unpredictable */
		/* condition by the CPU. */
		/* In such case the use of the conditional move is generally faster. */

		/* use also the high bit */
		pos = high_pos;
	}

	return tommy_hashlin_pos(hashlin, pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
andq 0x218(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
andq 0x208(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x220(%rcx), %rax
jae 0x4a3f
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movl $0x6, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x210(%rcx), %eax
jae 0x59d5
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x598f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x208(%rax), %rax
cmpq -0x10(%rbp), %rax
jb 0x5a06
jmp 0x5aa3
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x208(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x200(%rcx), %rax
jbe 0x5aa3
movq -0x8(%rbp), %rax
movq 0x200(%rax), %rdi
movl $0x8, %esi
callq 0x10a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subq 0x200(%rcx), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x210(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x210(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x210(%rax)
movq -0x8(%rbp), %rax
movl 0x210(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x200(%rax)
jmp 0x5a15
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x210(%rax), %rax
cmpq -0x10(%rbp), %rax
jb 0x5c36
jmp 0x5ce8
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x210(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x208(%rcx), %rax
jbe 0x5ce8
movq -0x8(%rbp), %rax
movq 0x208(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x200(%rax), %rsi
callq 0x10a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x208(%rax), %rcx
movq -0x8(%rbp), %rax
imulq 0x200(%rax), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x218(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x218(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x218(%rax)
movq -0x8(%rbp), %rax
movl 0x218(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x208(%rax)
jmp 0x5c45
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5dc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x5da4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5de0
movq %rax, %rdi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5d64
movq -0x8(%rbp), %rdi
callq 0x5970
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rax
cmpq -0x10(%rbp), %rax
jb 0x5e36
jmp 0x5ebd
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x218(%rax)
movq -0x10(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
subq $0x1, %rax
shrq $0xc, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5dc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5ebd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59e0
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5ebb
movl $0x1000, %edi           # imm = 0x1000
movl $0x8, %esi
callq 0x10a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5ed0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5e7f
jmp 0x5ebd
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5dc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x5fe4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5de0
movq %rax, %rdi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5fa4
movq -0x8(%rbp), %rdi
callq 0x5970
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rax
cmpq -0x10(%rbp), %rax
jb 0x6026
jmp 0x60b3
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x220(%rax)
movq -0x10(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
subq $0x1, %rax
shrq $0xc, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5dc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x60b3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59e0
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x60b1
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0x10a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5ed0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x606f
jmp 0x60b3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0x6570
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x6557
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x1b, %rax
cmpq $0x20, %rax
jae 0x6b58
jmp 0x6b77
leaq 0x39f1(%rip), %rdi      # 0xa550
leaq 0x3a21(%rip), %rsi      # 0xa587
movl $0x9e, %edx
leaq 0x3a29(%rip), %rcx      # 0xa59b
callq 0x1080
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x1b, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x1b, %esi
callq 0x6be0
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x100(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x1b, %rax
cmpq $0x20, %rax
jae 0x6d90
jmp 0x6daf
leaq 0x37b9(%rip), %rdi      # 0xa550
leaq 0x37e9(%rip), %rsi      # 0xa587
movl $0x105, %edx            # imm = 0x105
leaq 0x383e(%rip), %rcx      # 0xa5e8
callq 0x1080
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x1b, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %r8
movl $0x1b, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x6e30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6df5
movq $0x0, -0x8(%rbp)
jmp 0x6e17
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x100(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)