LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/htab.c
// Function: get_subhash
static inline cnthash_t *get_subhash(const bfc_ch_t *ch, const uint64_t x[2], uint64_t *key)
{
	if (ch->k <= 32) {
		int t = ch->k * 2 - ch->l_pre;
		uint64_t z = x[0] << ch->k | x[1];
		*key = (z & ((1ULL<<t) - 1)) << 14 | 1;
		return ch->h[z>>t];
	} else {
		int t = ch->k - ch->l_pre;
		int shift = t + ch->k < BFC_CH_KEYBITS? ch->k : BFC_CH_KEYBITS - t;
		*key = ((x[0] & ((1ULL<<t) - 1)) << shift ^ x[1]) << 14 | 1;
		return ch->h[x[0]>>t];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x20, (%rax)
jg 0x21548
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll %eax
movq -0x10(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
shlq %cl, %rax
movq -0x18(%rbp), %rcx
orq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq -0x40(%rbp), %rcx
subq $0x1, %rax
andq %rax, %rcx
shlq $0xe, %rcx
orq $0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x215de
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
addl (%rcx), %eax
cmpl $0x32, %eax
jge 0x21571
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x2157c
movl $0x32, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x34(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
andq %rcx, %rax
movl -0x38(%rbp), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
xorq 0x8(%rax), %rcx
shlq $0xe, %rcx
orq $0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movl -0x34(%rbp), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/htab.c
// Function: bfc_ch_get
int bfc_ch_get(const bfc_ch_t *ch, const uint64_t x[2])
{
	uint64_t key;
	cnthash_t *h;
	khint_t itr;
	h = get_subhash(ch, x, &key);
	itr = kh_get(cnt, h, key);
	return itr == kh_end(h)? -1 : kh_key(h, itr) & 0x3fff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x214b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x219d0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x219ad
movq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x219c6
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
andq $0x3fff, %rax           # imm = 0x3FFF
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/htab.c
// Function: bfc_ch_count
uint64_t bfc_ch_count(const bfc_ch_t *ch)
{
	int i;
	uint64_t cnt = 0;
	for (i = 0; i < 1<<ch->l_pre; ++i)
		cnt += kh_size(ch->h[i]);
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x21ce4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x21ca7
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/htab.c
// Function: bfc_ch_hist
int bfc_ch_hist(const bfc_ch_t *ch, uint64_t cnt[256], uint64_t high[64])
{
	int i, max_i = -1;
	uint64_t max;
	memset(cnt, 0, 256 * 8);
	memset(high, 0, 64 * 8);
	for (i = 0; i < 1<<ch->l_pre; ++i) {
		khint_t k;
		cnthash_t *h = ch->h[i];
		for (k = 0; k != kh_end(h); ++k)
			if (kh_exist(h, k))
				++cnt[kh_key(h, k) & 0xff], ++high[kh_key(h, k)>>8 & 0x3f];
	}
	for (i = 3, max = 0; i < 256; ++i)
		if (cnt[i] > max)
			max = cnt[i], max_i = i;
	return max_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x2110
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2110
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x21e09
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
je 0x21df9
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x2c(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x2c(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x21de9
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl -0x2c(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl -0x2c(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x8, %rcx
andq $0x3f, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x21deb
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x21d68
jmp 0x21dfb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21d32
movl $0x3, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
jge 0x21e56
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
jbe 0x21e49
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x21e4b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21e18
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/rope.c
// Function: rope_init
rope_t *rope_init(int max_nodes, int block_len)
{
	rope_t *rope;
	rope = calloc(1, sizeof(rope_t));
	if (block_len < 32) block_len = 32;
	rope->max_nodes = (max_nodes+ 1)>>1<<1;
	rope->block_len = (block_len + 7) >> 3 << 3;
	rope->node = mp_init(sizeof(rpnode_t) * rope->max_nodes);
	rope->leaf = mp_init(rope->block_len);
	rope->root = mp_alloc(rope->node);
	rope->root->n = 1;
	rope->root->is_bottom = 1;
	rope->root->p = mp_alloc(rope->leaf);
	return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, %edi
movl $0x50, %esi
callq 0x2140
movq %rax, -0x10(%rbp)
cmpl $0x20, -0x8(%rbp)
jge 0x2230e
movl $0x20, -0x8(%rbp)
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
sarl %ecx
shll %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
addl $0x7, %ecx
sarl $0x3, %ecx
shll $0x3, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movslq (%rax), %rax
shlq $0x6, %rax
movl %eax, %edi
callq 0x223f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x223f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x22450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movabsq $-0x7fc0000000000001, %rcx # imm = 0x803FFFFFFFFFFFFF
andq 0x8(%rax), %rcx
movabsq $0x40000000000000, %rdx # imm = 0x40000000000000
orq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq 0x8(%rax), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
orq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x22450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/rope.c
// Function: mp_init
static mempool_t *mp_init(int size)
{
	mempool_t *mp;
	mp = calloc(1, sizeof(mempool_t));
	mp->size = size;
	mp->i = mp->n_elems = MP_CHUNK_SIZE / size;
	mp->top = -1;
	return mp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x2140
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x100000, %eax         # imm = 0x100000
cltd
idivl -0x4(%rbp)
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/rope.c
// Function: mp_alloc
static inline void *mp_alloc(mempool_t *mp)
{
	if (mp->i == mp->n_elems) {
		if (++mp->top == mp->max) {
			mp->max = mp->max? mp->max<<1 : 1;
			mp->mem = realloc(mp->mem, sizeof(void*) * mp->max);
		}
		mp->mem[mp->top] = calloc(mp->n_elems, mp->size);
		mp->i = 0;
	}
	return mp->mem[mp->top] + (mp->i++) * mp->size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x22517
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x10(%rcx)
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x224e1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x224a6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shlq %rax
movq %rax, -0x10(%rbp)
jmp 0x224b1
movl $0x1, %eax
movq %rax, -0x10(%rbp)
jmp 0x224b1
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
shlq $0x3, %rsi
callq 0x21e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rsi
callq 0x2140
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdx
movl 0x4(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x4(%rdx)
movq -0x8(%rbp), %rdx
imull (%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/rope.c
// Function: rope_rank2a
void rope_rank2a(const rope_t *rope, int64_t x, int64_t y, int64_t *cx, int64_t *cy)
{
	rpnode_t *v;
	int64_t rest;
	v = rope_count_to_leaf(rope, x, cx, &rest);
	if (y < x || cy == 0) {
		rle_rank1a((const uint8_t*)v->p, rest, cx, v->c);
	} else if (rest + (y - x) <= v->l) {
		memcpy(cy, cx, 48);
		rle_rank2a((const uint8_t*)v->p, rest, rest + (y - x), cx, cy, v->c);
	} else {
		rle_rank1a((const uint8_t*)v->p, rest, cx, v->c);
		v = rope_count_to_leaf(rope, y, cy, &rest);
		rle_rank1a((const uint8_t*)v->p, rest, cy, v->c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x23020
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jl 0x22f16
cmpq $0x0, -0x28(%rbp)
jne 0x22f43
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r9
addq $0x10, %r9
movq $-0x1, %rdx
xorl %eax, %eax
movl %eax, %r8d
callq 0x24480
jmp 0x23017
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
subq -0x10(%rbp), %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rdx
movabsq $0x3fffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFF
andq 0x8(%rdx), %rcx
cmpq %rcx, %rax
ja 0x22fac
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x30, %edx
callq 0x2190
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
addq $0x10, %r9
callq 0x24480
jmp 0x23015
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r9
addq $0x10, %r9
movq $-0x1, %rdx
xorl %eax, %eax
movl %eax, %r8d
callq 0x24480
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x23020
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r9
addq $0x10, %r9
movq $-0x1, %rdx
xorl %eax, %eax
movl %eax, %r8d
callq 0x24480
jmp 0x23017
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/rope.c
// Function: rope_itr_first
void rope_itr_first(const rope_t *rope, rpitr_t *i)
{
	memset(i, 0, sizeof(rpitr_t));
	i->rope = rope;
	for (i->pa[i->d] = rope->root; !i->pa[i->d]->is_bottom;) // descend to the leftmost leaf
		++i->d, i->pa[i->d] = i->pa[i->d - 1]->p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x3d0, %edx            # imm = 0x3D0
callq 0x2110
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x3c8(%rcx), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x3c8(%rcx), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
shrq $0x3f, %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x232e2
jmp 0x23327
movq -0x10(%rbp), %rax
movl 0x3c8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c8(%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x3c8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x3c8(%rcx), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
jmp 0x232b7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/rope.c
// Function: rope_itr_next_block
const uint8_t *rope_itr_next_block(rpitr_t *i)
{
	const uint8_t *ret;
	assert(i->d < ROPE_MAX_DEPTH); // a B+ tree should not be that tall
	if (i->d < 0) return 0;
	ret = (uint8_t*)i->pa[i->d][i->ia[i->d]].p;
	while (i->d >= 0 && ++i->ia[i->d] == i->pa[i->d]->n) i->ia[i->d--] = 0; // backtracking
	if (i->d >= 0)
		while (!i->pa[i->d]->is_bottom) // descend to the leftmost leaf
			++i->d, i->pa[i->d] = i->pa[i->d - 1][i->ia[i->d - 1]].p;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x50, 0x3c8(%rax)
jge 0x2334b
jmp 0x2336a
leaq 0x2b23(%rip), %rdi      # 0x25e75
leaq 0x220a(%rip), %rsi      # 0x25563
movl $0xd3, %edx
leaq 0x2b26(%rip), %rcx      # 0x25e8b
callq 0x20f0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c8(%rax)
jge 0x23384
movq $0x0, -0x8(%rbp)
jmp 0x23502
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x3c8(%rcx), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq 0x3c8(%rdx), %rdx
movslq 0x288(%rcx,%rdx,4), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x3c8(%rcx)
movb %al, -0x19(%rbp)
jl 0x2341a
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq 0x3c8(%rax), %rdx
movl 0x288(%rcx,%rdx,4), %eax
addl $0x1, %eax
movl %eax, 0x288(%rcx,%rdx,4)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq 0x3c8(%rdx), %rdx
movq 0x8(%rcx,%rdx,8), %rcx
movq 0x8(%rcx), %rcx
shrq $0x36, %rcx
andq $0x1ff, %rcx            # imm = 0x1FF
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x23423
jmp 0x2344f
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x3c8(%rdx), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, 0x3c8(%rdx)
movslq %ecx, %rcx
movl $0x0, 0x288(%rax,%rcx,4)
jmp 0x233bd
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c8(%rax)
jl 0x234fa
jmp 0x23462
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x3c8(%rcx), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
shrq $0x3f, %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2348d
jmp 0x234f8
movq -0x10(%rbp), %rax
movl 0x3c8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c8(%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x3c8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
movl 0x3c8(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movslq 0x288(%rcx,%rdx,4), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x3c8(%rcx), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
jmp 0x23462
jmp 0x234fa
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/./rle.h
// Function: rle_enc1
static inline int rle_enc1(uint8_t *p, int c, int64_t l)
{
	if (l < 1LL<<4) {
		*p = l << 3 | c;
		return 1;
	} else if (l < 1LL<<8) {
		*p = 0xC0 | l >> 6 << 3 | c;
		p[1] = 0x80 | (l & 0x3f);
		return 2;
	} else if (l < 1LL<<19) {
		*p = 0xE0 | l >> 18 << 3 | c;
		p[1] = 0x80 | (l >> 12 & 0x3f);
		p[2] = 0x80 | (l >> 6 & 0x3f);
		p[3] = 0x80 | (l & 0x3f);
		return 4;
	} else {
		int i, shift = 36;
		*p = 0xF0 | l >> 42 << 3 | c;
		for (i = 1; i < 8; ++i, shift -= 6)
			p[i] = 0x80 | (l>>shift & 0x3f);
		return 8;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x10, -0x20(%rbp)
jge 0x23ed9
movq -0x20(%rbp), %rax
shlq $0x3, %rax
movslq -0x14(%rbp), %rcx
orq %rcx, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x24019
cmpq $0x100, -0x20(%rbp)     # imm = 0x100
jge 0x23f27
movq -0x20(%rbp), %rax
sarq $0x6, %rax
shlq $0x3, %rax
orq $0xc0, %rax
movslq -0x14(%rbp), %rcx
orq %rcx, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x24019
cmpq $0x80000, -0x20(%rbp)   # imm = 0x80000
jge 0x23fa8
movq -0x20(%rbp), %rax
sarq $0x12, %rax
shlq $0x3, %rax
orq $0xe0, %rax
movslq -0x14(%rbp), %rcx
orq %rcx, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
sarq $0xc, %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x20(%rbp), %rax
sarq $0x6, %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x20(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x24019
movl $0x24, -0x28(%rbp)
movq -0x20(%rbp), %rax
sarq $0x2a, %rax
shlq $0x3, %rax
orq $0xf0, %rax
movslq -0x14(%rbp), %rcx
orq %rcx, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x24012
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
sarq %cl, %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
subl $0x6, %eax
movl %eax, -0x28(%rbp)
jmp 0x23fd7
movl $0x8, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/rle.c
// Function: rle_split
void rle_split(uint8_t *block, uint8_t *new_block)
{
	int n = *(uint16_t*)block;
	uint8_t *end = block + 2 + n, *q = block + 2 + (n>>1);
	while (*q>>6 == 2) --q;
	memcpy(new_block + 2, q, end - q);
	*(uint16_t*)new_block = end - q;
	*(uint16_t*)block = q - block - 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movl -0x14(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
sarl $0x6, %eax
cmpl $0x2, %eax
jne 0x240f1
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x240d4
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
callq 0x2190
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
subq $0x2, %rax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/rle.c
// Function: rle_count
void rle_count(const uint8_t *block, int64_t cnt[6])
{
	const uint8_t *q = block + 2, *end = q + *(uint16_t*)block;
	while (q < end) {
		int c;
		int64_t l;
		rle_dec1(q, c, l);
		cnt[c] += l;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movzwl (%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x242ab
jmp 0x2418d
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0x7, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x241d9
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
sarl $0x3, %eax
cltq
movq %rax, -0x30(%rbp)
jmp 0x24290
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
sarl $0x5, %eax
cmpl $0x6, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x24226
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andq $0x18, %rax
shlq $0x3, %rax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andq $0x3f, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x2428e
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0x10, %eax
sarl $0x2, %eax
addl $0x4, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
sarl $0x3, %eax
andl $0x1, %eax
cltq
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x2428c
movq -0x30(%rbp), %rax
shlq $0x6, %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
andq $0x3f, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x24257
jmp 0x2428e
jmp 0x24290
jmp 0x24292
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x2417d
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/rle.c
// Function: rle_print
void rle_print(const uint8_t *block, int expand)
{
	const uint16_t *p = (const uint16_t*)block;
	const uint8_t *q = block + 2, *end = block + 2 + *p;
	while (q < end) {
		int c;
		int64_t l, x;
		rle_dec1(q, c, l);
		if (expand) for (x = 0; x < l; ++x) putchar("$ACGTN"[c]);
		else printf("%c%ld", "$ACGTN"[c], (long)l);
	}
	putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x24463
jmp 0x242fc
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0x7, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x24348
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
sarl $0x3, %eax
cltq
movq %rax, -0x38(%rbp)
jmp 0x243ff
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
sarl $0x5, %eax
cmpl $0x6, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x24395
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andq $0x18, %rax
shlq $0x3, %rax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andq $0x3f, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x243fd
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0x10, %eax
sarl $0x2, %eax
addl $0x4, %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
sarl $0x3, %eax
andl $0x1, %eax
cltq
movq %rax, -0x38(%rbp)
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
je 0x243fb
movq -0x38(%rbp), %rax
shlq $0x6, %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movzbl (%rcx), %ecx
andq $0x3f, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x243c6
jmp 0x243fd
jmp 0x243ff
jmp 0x24401
cmpl $0x0, -0xc(%rbp)
je 0x2443d
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x2443b
movslq -0x2c(%rbp), %rcx
leaq 0xf2c(%rip), %rax       # 0x25350
movsbl (%rax,%rcx), %edi
callq 0x2050
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2440f
jmp 0x2445e
movslq -0x2c(%rbp), %rcx
leaq 0xf08(%rip), %rax       # 0x25350
movsbl (%rax,%rcx), %esi
movq -0x38(%rbp), %rdx
leaq 0x1a6a(%rip), %rdi      # 0x25ec1
movb $0x0, %al
callq 0x20d0
jmp 0x242ec
movl $0xa, %edi
callq 0x2050
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort.c
// Function: comparator
static int comparator(void *left, void *right)
{
    ll *lfl = (ll *) left, *rl = (ll *) right;
    char *l = get_data(lfl), *r = get_data(rl);
    int n = strcmp(l, r);
    if (n < 0)
        return -1;
    else if (n > 0)
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2550
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2550
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x10c0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0x2e49
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e5f
cmpl $0x0, -0x3c(%rbp)
jle 0x2e58
movl $0x1, -0x4(%rbp)
jmp 0x2e5f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort.c
// Function: cleanup
static void cleanup(aa * tree, bool numer)
{
    if (numer) {
        aa_traverse(tree, freedatan, TRAV_IN);
    } else {
        aa_traverse(tree, freedata, TRAV_IN);
    }

    aa_free(tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x31ce
movq -0x8(%rbp), %rdi
leaq 0x50b(%rip), %rsi       # 0x36d0
xorl %edx, %edx
callq 0x1af0
jmp 0x31e0
movq -0x8(%rbp), %rdi
leaq 0x537(%rip), %rsi       # 0x3710
xorl %edx, %edx
callq 0x1af0
movq -0x8(%rbp), %rdi
callq 0x1d30
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort.c
// Function: usage
static void usage(char *pname)
{
    printf("Usage: %s [OPTION] [FILE...]\n", pname);
    puts("Sort files or, if no files on the command line, sort stdin.");
    puts("All files sorted together into one output.");
    puts("");
    puts("  -u, --uniqify     Only print identical lines once");
    puts("  -r, --reverse     Reverse the sense of the comparison");
    puts("  -n, --numer       Sort numerically, then non-numerically");
    puts("  -h, --help        Print this help");
    puts("  -v, --version     Print version information");
    puts("");
    puts("Report bugs to <chbarts@gmail.com>.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xf29(%rip), %rdi       # 0x4130
movb $0x0, %al
callq 0x1080
leaq 0xf39(%rip), %rdi       # 0x414e
callq 0x1040
leaq 0xf69(%rip), %rdi       # 0x418a
callq 0x1040
leaq 0xe60(%rip), %rdi       # 0x408d
callq 0x1040
leaq 0xf7c(%rip), %rdi       # 0x41b5
callq 0x1040
leaq 0xfa4(%rip), %rdi       # 0x41e9
callq 0x1040
leaq 0xfd0(%rip), %rdi       # 0x4221
callq 0x1040
leaq 0xfff(%rip), %rdi       # 0x425c
callq 0x1040
leaq 0x1017(%rip), %rdi      # 0x4280
callq 0x1040
leaq 0xe18(%rip), %rdi       # 0x408d
callq 0x1040
leaq 0x102d(%rip), %rdi      # 0x42ae
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort.c
// Function: version
static void version(void)
{
    puts("sort version 0.5.0");
    puts("Copyright 2014 Chris Barts.");
    puts("sort comes with NO WARRANTY to the extent permitted by law.");
    puts("You may redistribute this software under the terms");
    puts("of the GNU General Public License.");
    puts("For more information, see the file named COPYING");
    puts("in this program's distribution file.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1037(%rip), %rdi      # 0x42d2
callq 0x1040
leaq 0x103e(%rip), %rdi      # 0x42e5
callq 0x1040
leaq 0x104e(%rip), %rdi      # 0x4301
callq 0x1040
leaq 0x107e(%rip), %rdi      # 0x433d
callq 0x1040
leaq 0x10a5(%rip), %rdi      # 0x4370
callq 0x1040
leaq 0x10bc(%rip), %rdi      # 0x4393
callq 0x1040
leaq 0x10e1(%rip), %rdi      # 0x43c4
callq 0x1040
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort.c
// Function: rncomparator
static int rncomparator(void *left, void *right)
{
    tstruct *lv = (tstruct *) left, *rv = (tstruct *) right;

    if (lv->num < rv->num)
        return 1;
    else if (lv->num > rv->num)
        return -1;
    else
        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)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x3325
movl $0x1, -0x4(%rbp)
jmp 0x3345
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x333e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3345
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort.c
// Function: ncomparator
static int ncomparator(void *left, void *right)
{
    tstruct *lv = (tstruct *) left, *rv = (tstruct *) right;

    if (lv->num < rv->num)
        return -1;
    else if (lv->num > rv->num)
        return 1;
    else
        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)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x3385
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x33a5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x339e
movl $0x1, -0x4(%rbp)
jmp 0x33a5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort.c
// Function: nduplicate
static int nduplicate(void *orig, void *new)
{
    ll *val;
    tstruct *node = (tstruct *) orig, *node2 = (tstruct *) new;
    aa *ttree;

    aa_to_root(node2->tree);
    val = aa_get_here(node2->tree);
    ttree = node->tree;

    switch (aa_add(node->tree, val, duplicate)) {
    case 0:
        break;
    case 2:                    /* memory error */
        free(node);
        cleanup(node2->tree, false);
        free(node2);
        error(ttree, false);
        break;
    default:                   /* can't happen */
        fprintf(stderr, "can't happen\n");
        free(node);
        cleanup(ttree, false);
        cleanup(node2->tree, false);
        free(node2);
        exit(EXIT_FAILURE);
        break;
    }

    aa_free(node2->tree);
    free(node2);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1dc0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0xcd(%rip), %rdx       # 0x3540
callq 0x14a0
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
testl %eax, %eax
je 0x3627
jmp 0x361d
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x3629
jmp 0x3657
jmp 0x36a5
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x31a0
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x34f0
jmp 0x36a5
movq 0x399a(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0xaac(%rip), %rsi       # 0x4114
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x31a0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x31a0
movq -0x28(%rbp), %rdi
callq 0x1030
movl $0x1, %edi
callq 0x1140
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1d30
movq -0x28(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/sort.c
// Function: freedatan
static void *freedatan(void *data)
{
    tstruct *node = (tstruct *) data;
    cleanup(node->tree, false);
    free(node);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x31a0
movq -0x10(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/avik-das[P]seam-carver/seam-carver.c
// Function: compute_energy
unsigned int * compute_energy(const unsigned char *data, int w, int h) {
    unsigned int *energy = malloc(w * h * sizeof(unsigned int));
    if (!energy) {
        fprintf(stderr, "Unable to allocate memory (%d)\n", __LINE__);
        return NULL;
    }

    for (int y = 0; y < h; y++)
    for (int x = 0; x < w; x++) {
        int i = y * w + x;
        energy[i] = energy_at(data, w, h, x, y);
    }

    return energy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6027
movq 0x20ff1(%rip), %rax     # 0x26ff8
movq (%rax), %rdi
leaq 0x1bd0b(%rip), %rsi     # 0x21d1c
movl $0x2a, %edx
movb $0x0, %al
callq 0x1100
movq $0x0, -0x8(%rbp)
jmp 0x6095
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x608d
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6080
movl -0x24(%rbp), %eax
imull -0x14(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq 0x5de0
movl %eax, %edx
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x603d
jmp 0x6082
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x602e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/avik-das[P]seam-carver/seam-carver.c
// Function: get_minimal_seam
int * get_minimal_seam(
        const struct seam_link *seam_links,
        int num_seams,
        int seam_length) {
    int *minimal_seam = malloc(seam_length * sizeof(int));
    if (!minimal_seam) {
        fprintf(stderr, "Unable to allocate memory (%d)\n", __LINE__);

        goto cleanup;
    }

    int min_coordinate = -1;
    int min_energy = INT_MAX;

    for (int coordinate = 0; coordinate < num_seams; coordinate++) {
        int i = num_seams * (seam_length - 1) + coordinate;
        if (seam_links[i].energy < min_energy) {
            min_coordinate = coordinate;
            min_energy = seam_links[i].energy;
        }
    }

    int i = 0;
    int offset = min_coordinate;

    for (int d = 0; d < seam_length; d++) {
        minimal_seam[i++] = offset;

        struct seam_link end =
            seam_links[num_seams * (seam_length - 1 - d) + offset];

        offset = end.parent_coordinate;
    }

cleanup:
    return minimal_seam;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0x10(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1150
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x62ac
movq 0x20d67(%rip), %rax     # 0x26ff8
movq (%rax), %rdi
leaq 0x1ba81(%rip), %rsi     # 0x21d1c
movl $0x75, %edx
movb $0x0, %al
callq 0x1100
jmp 0x6374
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x630c
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,8), %eax
cmpl -0x20(%rbp), %eax
jae 0x62ff
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movl %eax, -0x20(%rbp)
jmp 0x6301
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x62c1
movl $0x0, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6372
movl -0x30(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x2c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %edx
subl $0x1, %edx
subl -0x34(%rbp), %edx
imull %edx, %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6320
jmp 0x6374
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/avik-das[P]seam-carver/seam-carver.c
// Function: image_after_vertical_seam_removal
unsigned char * image_after_vertical_seam_removal(
        const unsigned char *original_data,
        const int *vertical_seam,
        int w,
        int h) {
    unsigned char *img = malloc((w - 1) * h * 3);
    if (!img) {
        fprintf(stderr, "Unable to allocate memory (%d)\n", __LINE__);
        return NULL;
    }

    for (int y = 0; y < h; y++) {
        int seamx = vertical_seam[h - 1 - y];

        for (int x = 0, imgx = 0; imgx < w - 1; x++, imgx++) {
            if (x == seamx) { x++; }

            int    i = (y *  w      + x   ) * 3;
            int imgi = (y * (w - 1) + imgx) * 3;

            img[imgi    ] = original_data[i    ];
            img[imgi + 1] = original_data[i + 1];
            img[imgi + 2] = original_data[i + 2];
        }
    }

    return img;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
imull -0x20(%rbp), %eax
imull $0x3, %eax, %eax
movslq %eax, %rdi
callq 0x1150
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x63e0
movq 0x20c3b(%rip), %rax     # 0x26ff8
movq (%rax), %rdi
leaq 0x1b955(%rip), %rsi     # 0x21d1c
movl $0x9e, %edx
movb $0x0, %al
callq 0x1100
movq $0x0, -0x8(%rbp)
jmp 0x64e3
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x64db
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
subl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x64cb
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x6439
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %eax
imull -0x1c(%rbp), %eax
addl -0x34(%rbp), %eax
imull $0x3, %eax, %eax
movl %eax, -0x3c(%rbp)
movl -0x2c(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
addl -0x38(%rbp), %eax
imull $0x3, %eax, %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x40(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x40(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x6417
jmp 0x64cd
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x63e7
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/avik-das[P]seam-carver/seam-carver.c
// Function: draw_vertical_seam
int draw_vertical_seam(
        const unsigned char *data,
        const int *minimal_vertical_seam,
        int w,
        int h,
        const char *filename) {
    int result = 0;

    unsigned char *data_with_seams = malloc(w * h * 3);
    if (!data_with_seams) {
        fprintf(stderr, "Unable to allocate memory (%d)\n", __LINE__);

        result = 1;
        goto cleanup;
    }

    memcpy(data_with_seams, data, w * h * 3);

    for (int y = h - 1; y >= 0; y--) {
        int x = minimal_vertical_seam[h - 1 - y];
        int i = (y * w + x) * 3;

        data_with_seams[i    ] = 255;
        data_with_seams[i + 1] = 0;
        data_with_seams[i + 2] = 0;
    }

    printf("Writing to '%s'\n", filename);
    if (!stbi_write_jpg(filename, w, h, 3, data_with_seams, 80)) {
        fprintf(stderr, "Unable to write output (%d)\n", __LINE__);

        result = 1;
        goto cleanup;
    }

cleanup:
    if (data_with_seams) { free(data_with_seams); }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
imull $0x3, %eax, %eax
movslq %eax, %rdi
callq 0x1150
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6727
movq 0x208f3(%rip), %rax     # 0x26ff8
movq (%rax), %rdi
leaq 0x1b60d(%rip), %rsi     # 0x21d1c
movl $0xea, %edx
movb $0x0, %al
callq 0x1100
movl $0x1, -0x24(%rbp)
jmp 0x680c
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
imull $0x3, %eax, %eax
movslq %eax, %rdx
callq 0x1140
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x67af
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
subl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
imull -0x14(%rbp), %eax
addl -0x38(%rbp), %eax
imull $0x3, %eax, %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb $-0x1, (%rax,%rcx)
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x674a
movq -0x20(%rbp), %rsi
leaq 0x1b582(%rip), %rdi     # 0x21d3c
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x30(%rbp), %r8
movl $0x3, %ecx
movl $0x50, %r9d
callq 0x5d70
cmpl $0x0, %eax
jne 0x680a
movq 0x2080d(%rip), %rax     # 0x26ff8
movq (%rax), %rdi
leaq 0x1b558(%rip), %rsi     # 0x21d4d
movl $0xfd, %edx
movb $0x0, %al
callq 0x1100
movl $0x1, -0x24(%rbp)
jmp 0x680c
jmp 0x680c
cmpq $0x0, -0x30(%rbp)
je 0x681c
movq -0x30(%rbp), %rdi
callq 0x1030
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/avik-das[P]seam-carver/seam-carver.c
// Function: show_usage
void show_usage(const char *program) {
    fprintf(
            stderr,
            "USAGE:\n"
            "  %s <input-filename> <output-directory> <num-iterations>\n",
            program);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x20755(%rip), %rax     # 0x26ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1b4d6(%rip), %rsi     # 0x21d87
movb $0x0, %al
callq 0x1100
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Sound/sound.c
// Function: Make_wav_header
struct wav_header *Make_wav_header(unsigned int length_data)
{
	struct wav_header *new_header = NULL;

	if (!(new_header = malloc(sizeof (struct wav_header))))
	{
		perror("malloc()");
		return NULL;
	}
	memcpy(new_header->FileTypeBlocID, "RIFF", 4);
	new_header->FileSize = length_data + sizeof (struct wav_header) - 8;
	memcpy(new_header->FileFormatID, "WAVE", 4);
	memcpy(new_header->FormatBlocID, "fmt ", 4);
	new_header->BlocSize = 0x10;
	new_header->AudioFormat = 0x01;
	new_header->NumOfChan = 0x01;
	new_header->Frequency = 11025;

	new_header->BitsPerSample = 16;
	new_header->BytePerBloc = new_header->NumOfChan * new_header->BitsPerSample / 8;
	new_header->BytePerSec = new_header->Frequency * new_header->BytePerBloc;

	memcpy(new_header->DataBlocID, "data", 4);
	new_header->DataSize = length_data;
	return new_header;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x2c, %edi
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1200
leaq 0xe16(%rip), %rdi       # 0x2004
callq 0x10a0
movq $0x0, -0x8(%rbp)
jmp 0x12cc
movq -0x18(%rbp), %rax
movl 0xe03(%rip), %ecx       # 0x200d
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
addq $0x2c, %rax
subq $0x8, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0xde8(%rip), %ecx       # 0x2012
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0xde0(%rip), %ecx       # 0x2017
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl $0x10, 0x10(%rax)
movq -0x18(%rbp), %rax
movw $0x1, 0x14(%rax)
movq -0x18(%rbp), %rax
movw $0x1, 0x16(%rax)
movq -0x18(%rbp), %rax
movl $0x2b11, 0x18(%rax)     # imm = 0x2B11
movq -0x18(%rbp), %rax
movw $0x10, 0x22(%rax)
movq -0x18(%rbp), %rax
movzwl 0x16(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x22(%rcx), %ecx
imull %ecx, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x18(%rbp), %rax
movzwl 0x20(%rax), %eax
imull %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movl 0xd65(%rip), %ecx       # 0x201c
movl %ecx, 0x24(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)