LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_squeeze
int32_t *sd_squeeze(sdict_t *d)
{
	int32_t *map, i, j;
	if (d->h) {
		kh_destroy(str, (shash_t*)d->h);
		d->h = 0;
	}
	map = (int32_t*)calloc(d->n_seq, 4);
	for (i = j = 0; i < d->n_seq; ++i) {
		if (d->seq[i].del) {
			free(d->seq[i].name);
			map[i] = -1;
		} else d->seq[j] = d->seq[i], map[i] = j++;
	}
	d->n_seq = j;
	sd_hash(d);
	return map;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x35f4
movq 0x18(%r14), %rdi
callq 0x1040
movq 0x10(%r14), %rdi
callq 0x1040
movq 0x20(%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq $0x0, 0x10(%rbx)
movl (%rbx), %r15d
movl $0x4, %esi
movq %r15, %rdi
callq 0x10f0
movq %rax, %r14
testq %r15, %r15
je 0x365c
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
leaq (%rax,%r15,4), %rcx
cmpl $0x0, 0xc(%rcx)
js 0x363b
movl %ebp, %edx
movslq %ebp, %rsi
movq %rsi, %rdi
shlq $0x4, %rdi
movups (%rcx), %xmm0
movups %xmm0, (%rax,%rdi)
incl %esi
movl %esi, %ebp
jmp 0x3648
movq (%rcx), %rdi
callq 0x1040
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, (%r14,%r15)
incq %r12
movl (%rbx), %eax
addq $0x4, %r15
cmpq %rax, %r12
jb 0x3614
jmp 0x365e
xorl %ebp, %ebp
movl %ebp, (%rbx)
movq %rbx, %rdi
callq 0x353e
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/paf.c
// Function: paf_open
paf_file_t *paf_open(const char *fn)
{
	kstream_t *ks;
	gzFile fp;
	paf_file_t *pf;
	fp = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
	if (fp == 0) return 0;
	ks = ks_init(fp);
	pf = (paf_file_t*)calloc(1, sizeof(paf_file_t));
	pf->fp = ks;
	return pf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3979
movq %rdi, %rbx
leaq 0x6c42(%rip), %rsi      # 0xa5a1
callq 0x1100
testl %eax, %eax
je 0x3979
leaq 0x66ed(%rip), %rsi      # 0xa05c
movq %rbx, %rdi
callq 0x11a0
jmp 0x3996
movq 0xb648(%rip), %rax      # 0xefc8
movq (%rax), %rdi
callq 0x1150
leaq 0x66cd(%rip), %rsi      # 0xa05c
movl %eax, %edi
callq 0x1080
movq %rax, %rbx
testq %rax, %rax
je 0x39e5
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %rax, %r14
movq %rbx, 0x10(%rax)
movl 0x8(%rax), %eax
andl $0x3, %eax
orl $0x40000, %eax          # imm = 0x40000
movl %eax, 0x8(%r14)
movl $0x10000, %edi          # imm = 0x10000
callq 0x1160
movq %rax, 0x18(%r14)
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %r14, (%rax)
jmp 0x39e7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/paf.c
// Function: paf_close
int paf_close(paf_file_t *pf)
{
	kstream_t *ks;
	if (pf == 0) return 0;
	free(pf->buf.s);
	ks = (kstream_t*)pf->fp;
	gzclose(ks->f);
	ks_destroy(ks);
	free(pf);
	return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x3a35
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040
movq (%rbx), %r14
movq 0x10(%r14), %rdi
callq 0x1030
testq %r14, %r14
je 0x3a26
movq 0x18(%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1040
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/paf.c
// Function: paf_parse
int paf_parse(int l, char *s, paf_rec_t *pr) // s must be NULL terminated
{ // on return: <0 for failure; 0 for success; >0 for filtered
	char *q, *r;
	int i, t;
	for (i = t = 0, q = s; i <= l; ++i) {
		if (i < l && s[i] != '\t') continue;
		s[i] = 0;
		if (t == 0) pr->qn = q;
		else if (t == 1) pr->ql = strtol(q, &r, 10);
		else if (t == 2) pr->qs = strtol(q, &r, 10);
		else if (t == 3) pr->qe = strtol(q, &r, 10);
		else if (t == 4) pr->rev = (*q == '-');
		else if (t == 5) pr->tn = q;
		else if (t == 6) pr->tl = strtol(q, &r, 10);
		else if (t == 7) pr->ts = strtol(q, &r, 10);
		else if (t == 8) pr->te = strtol(q, &r, 10);
		else if (t == 9) pr->ml = strtol(q, &r, 10);
		else if (t == 10) pr->bl = strtol(q, &r, 10);
		++t, q = i < l? &s[i+1] : 0;
	}
	if (t < 10) return -1;
	return 0;
}

// Assembly:
testl %edi, %edi
js 0x3b93
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movl %edi, %r13d
incl %r15d
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %rsi, %rdi
cmpq %r13, %r12
jae 0x3a72
cmpb $0x9, (%r14,%r12)
jne 0x3b6e
movb $0x0, (%r14,%r12)
cmpl $0xa, %ebp
ja 0x3b5b
movl %ebp, %eax
leaq 0x65a7(%rip), %rcx      # 0xa030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdi, (%rbx)
jmp 0x3b5b
xorl %eax, %eax
cmpb $0x2d, (%rdi)
sete %al
shll $0x1f, %eax
movl 0x28(%rbx), %ecx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl %edx, %ecx
orl %eax, %ecx
jmp 0x3ad1
movq %rsp, %rsi
movl $0xa, %edx
callq 0x1130
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl 0x28(%rbx), %ecx
movl $0x80000000, %edx       # imm = 0x80000000
andl %edx, %ecx
orl %eax, %ecx
movl %ecx, 0x28(%rbx)
jmp 0x3b5b
movq %rsp, %rsi
movl $0xa, %edx
callq 0x1130
movl %eax, 0x14(%rbx)
jmp 0x3b5b
movq %rsp, %rsi
movl $0xa, %edx
callq 0x1130
movl %eax, 0x18(%rbx)
jmp 0x3b5b
movq %rsp, %rsi
movl $0xa, %edx
callq 0x1130
movl %eax, 0x20(%rbx)
jmp 0x3b5b
movq %rsp, %rsi
movl $0xa, %edx
callq 0x1130
movl %eax, 0x10(%rbx)
jmp 0x3b5b
movq %rdi, 0x8(%rbx)
jmp 0x3b5b
movq %rsp, %rsi
movl $0xa, %edx
callq 0x1130
movl %eax, 0x1c(%rbx)
jmp 0x3b5b
movq %rsp, %rsi
movl $0xa, %edx
callq 0x1130
movl %eax, 0x2c(%rbx)
jmp 0x3b5b
movq %rsp, %rsi
movl $0xa, %edx
callq 0x1130
movl %eax, 0x24(%rbx)
incl %ebp
cmpq %r13, %r12
leaq 0x1(%r14,%r12), %rdi
movl $0x0, %eax
cmovaeq %rax, %rdi
incq %r12
cmpq %r12, %r15
jne 0x3a62
xorl %eax, %eax
cmpl $0xa, %ebp
setl %al
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/paf.c
// Function: paf_read
int paf_read(paf_file_t *pf, paf_rec_t *r)
{
	int ret, dret;
file_read_more:
	ret = ks_getuntil((kstream_t*)pf->fp, KS_SEP_LINE, &pf->buf, &dret);
	if (ret < 0) return ret;
	ret = paf_parse(pf->buf.l, pf->buf.s, r);
	if (ret < 0) goto file_read_more;
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %r15
movq $0x0, 0x8(%r14)
movl (%r15), %eax
cmpl 0x4(%r15), %eax
jl 0x3bcc
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x3, 0x8(%r15)
jne 0x3d35
movl (%r15), %eax
cmpl 0x4(%r15), %eax
jl 0x3c1b
movl 0x8(%r15), %edx
testb $0x3, %dl
jne 0x3ce7
movl $0x0, (%r15)
movq 0x10(%r15), %rdi
movq 0x18(%r15), %rsi
sarl $0x2, %edx
callq 0x1110
movl %eax, 0x4(%r15)
movl 0x8(%r15), %ecx
movl %ecx, %edx
sarl $0x2, %edx
cmpl %edx, %eax
jge 0x3c13
andl $-0x4, %ecx
incl %ecx
movl %ecx, 0x8(%r15)
testl %eax, %eax
je 0x3ce7
movl (%r15), %eax
movl 0x4(%r15), %ecx
movl %eax, %r12d
cmpl %ecx, %eax
jge 0x3c46
movslq %eax, %rdx
addq 0x18(%r15), %rdx
movl %eax, %r12d
cmpb $0xa, (%rdx)
je 0x3c46
incl %r12d
incq %rdx
cmpl %r12d, %ecx
jne 0x3c33
movl %ecx, %r12d
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rsi
subq %rcx, %rsi
movl %r12d, %edx
subl %eax, %edx
leal 0x1(%rdx), %eax
cltq
cmpq %rax, %rsi
jae 0x3cab
movslq %edx, %rax
addq %rax, %rcx
movq %rcx, %rax
shrq %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rsi
shrq $0x10, %rsi
orq %rcx, %rsi
incq %rsi
movq %rsi, 0x10(%r14)
movq 0x18(%r14), %rdi
callq 0x1180
movq %rax, 0x18(%r14)
movq 0x18(%r14), %rdi
addq 0x8(%r14), %rdi
movslq (%r15), %rax
movq 0x18(%r15), %rsi
addq %rax, %rsi
movslq %r12d, %r13
movq %r13, %rdx
subq %rax, %rdx
callq 0x1140
movslq (%r15), %rax
subq %rax, %r13
addq %r13, 0x8(%r14)
leal 0x1(%r12), %eax
movl %eax, (%r15)
cmpl 0x4(%r15), %r12d
jge 0x3bcc
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x3d0a
movq 0x8(%r14), %rax
cmpq $0x2, %rax
jb 0x3d25
cmpb $0xd, -0x1(%rcx,%rax)
jne 0x3d25
decq %rax
movq %rax, 0x8(%r14)
jmp 0x3d25
movq $0x1, 0x10(%r14)
movl $0x1, %edi
movl $0x1, %esi
callq 0x10f0
movq %rax, 0x18(%r14)
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movb $0x0, (%rcx,%rax)
movl 0x8(%r14), %eax
testl %eax, %eax
js 0x3d53
movl 0x8(%r14), %edi
movq 0x18(%r14), %rsi
movq %rbx, %rdx
callq 0x3a38
testl %eax, %eax
js 0x3ba8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asg.c
// Function: asg_arc_index_core
uint64_t *asg_arc_index_core(size_t max_seq, size_t n, const asg_arc_t *a)
{
	size_t i, last;
	uint64_t *idx;
	idx = (uint64_t*)calloc(max_seq * 2, 8);
	for (i = 1, last = 0; i <= n; ++i)
		if (i == n || a[i-1].ul>>32 != a[i].ul>>32)
			idx[a[i-1].ul>>32] = (uint64_t)last<<32 | (i - last), last = i;
	return idx;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
addq %rdi, %rdi
movl $0x8, %esi
callq 0x10f0
testq %r14, %r14
je 0x403a
leaq 0x1(%r14), %rdx
cmpq $0x3, %rdx
movl $0x2, %ecx
cmovaeq %rdx, %rcx
movl $0x1, %edx
xorl %esi, %esi
cmpq %rdx, %r14
je 0x4017
movq 0x10(%rbx), %rdi
xorq (%rbx), %rdi
shrq $0x20, %rdi
je 0x402e
movq %rdx, %rdi
subq %rsi, %rdi
shlq $0x20, %rsi
orq %rdi, %rsi
movl 0x4(%rbx), %edi
movq %rsi, (%rax,%rdi,8)
movq %rdx, %rsi
incq %rdx
addq $0x10, %rbx
cmpq %rdx, %rcx
jne 0x4005
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asg.c
// Function: asg_seq_set
void asg_seq_set(asg_t *g, int sid, int len, int del)
{
	if (sid >= g->m_seq) {
		g->m_seq = sid + 1;
		kv_roundup32(g->m_seq);
		g->seq = (asg_seq_t*)realloc(g->seq, g->m_seq * sizeof(asg_seq_t));
	}
	if (sid >= g->n_seq) g->n_seq = sid + 1;
	g->seq[sid].len = len;
	g->seq[sid].del = !!del;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
cmpl %esi, 0x10(%rdi)
ja 0x40c5
movl %r15d, %eax
shrl %eax
orl %r15d, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %esi
shrl $0x10, %esi
orl %ecx, %esi
incl %esi
movl %esi, 0x10(%r14)
movq 0x18(%r14), %rdi
shlq $0x2, %rsi
callq 0x1180
movq %rax, 0x18(%r14)
movl 0x14(%r14), %eax
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %r15d, %ecx
jg 0x40eb
leal 0x1(%r15), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
andl $0x80000000, %eax       # imm = 0x80000000
orl %ecx, %eax
movl %eax, 0x14(%r14)
movq 0x18(%r14), %rax
movslq %r15d, %rcx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl $0x80000000, %esi       # imm = 0x80000000
andl (%rax,%rcx,4), %esi
andl %edx, %ebp
orl %ebp, %esi
movl %esi, (%rax,%rcx,4)
xorl %eax, %eax
testl %ebx, %ebx
setne %al
movq 0x18(%r14), %rsi
shll $0x1f, %eax
andl (%rsi,%rcx,4), %edx
orl %eax, %edx
movl %edx, (%rsi,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asg.c
// Function: asg_arc_rm
void asg_arc_rm(asg_t *g)
{
	uint32_t e, n;
	for (e = n = 0; e < g->n_arc; ++e) {
		uint32_t u = g->arc[e].ul>>32, v = g->arc[e].v;
		if (!g->arc[e].del && !g->seq[u>>1].del && !g->seq[v>>1].del)
			g->arc[n++] = g->arc[e];
	}
	if (n < g->n_arc) { // arc index is out of sync
		if (g->idx) free(g->idx);
		g->idx = 0;
	}
	g->n_arc = n;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl 0x4(%rdi), %edx
je 0x4193
xorl %eax, %eax
xorl %ecx, %ecx
xorl %ebp, %ebp
movq 0x8(%rbx), %rdx
cmpl $0x0, 0xc(%rdx,%rax)
js 0x417c
leaq (%rdx,%rax), %rsi
movq (%rsi), %r8
movq 0x18(%rbx), %rdi
shrq $0x21, %r8
cmpl $0x0, (%rdi,%r8,4)
js 0x417c
movl 0x8(%rdx,%rax), %r8d
shrl %r8d
cmpl $0x0, (%rdi,%r8,4)
js 0x417c
movl %ebp, %edi
incl %ebp
shlq $0x4, %rdi
movups (%rsi), %xmm0
movups %xmm0, (%rdx,%rdi)
incq %rcx
movl 0x4(%rbx), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
addq $0x10, %rax
cmpq %rdx, %rcx
jb 0x413d
jmp 0x4195
xorl %ebp, %ebp
cmpl %edx, %ebp
jae 0x41af
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x41a7
callq 0x1040
movq $0x0, 0x20(%rbx)
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movl $0x80000000, %eax       # imm = 0x80000000
andl 0x4(%rbx), %eax
orl %ebp, %eax
movl %eax, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asg.c
// Function: asg_cleanup
void asg_cleanup(asg_t *g)
{
	asg_arc_rm(g);
	if (!g->is_srt) {
		asg_arc_sort(g);
		g->is_srt = 1;
	}
	if (g->idx == 0) asg_arc_index(g);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4127
movslq 0x4(%rbx), %rsi
testq %rsi, %rsi
js 0x41ef
movq 0x8(%rbx), %rdi
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f56
orb $-0x80, 0x7(%rbx)
cmpq $0x0, 0x20(%rbx)
je 0x41f8
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x4042
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asg.c
// Function: asg_extend
int asg_extend(const asg_t *g, uint32_t v, int max_ext, asg64_v *a)
{
	int ret;
	uint64_t lw;
	a->n = 0;
	kv_push(uint64_t, *a, v);
	do {
		ret = asg_is_utg_end(g, v^1, &lw);
		if (ret != 0) break;
		kv_push(uint64_t, *a, lw);
		v = (uint32_t)lw;
	} while (--max_ext > 0);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
movq $0x0, (%rcx)
cmpq $0x0, 0x8(%rcx)
jne 0x4257
movq $0x2, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movl $0x10, %esi
callq 0x1180
movq %rax, 0x10(%rbx)
movl %r12d, %eax
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, (%rbx)
movq %rax, (%rdx,%rcx,8)
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movl %r12d, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, %rdx
shrq $0x20, %rdx
shlq $0x4, %rdx
andq %r13, %rsi
je 0x42c7
leaq (%rax,%rdx), %r9
addq $0xc, %r9
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
xorl %edi, %edi
xorl %r11d, %r11d
cmpl $0x0, (%r9)
setns %r11b
cmovnsl %r10d, %r8d
addl %r11d, %edi
incq %r10
addq $0x10, %r9
cmpq %r10, %rsi
jne 0x42a4
movslq %r8d, %rsi
jmp 0x42d0
xorl %edi, %edi
movq $-0x1, %rsi
testl %edi, %edi
je 0x4336
cmpl $0x1, %edi
jne 0x433d
addq %rax, %rdx
shlq $0x4, %rsi
movq (%rdx,%rsi), %r12
shlq $0x20, %r12
movl 0x8(%rdx,%rsi), %edx
orq %rdx, %r12
xorq $0x1, %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, %rcx
andq %r13, %rcx
je 0x4344
shrq $0x20, %rdx
shlq $0x4, %rcx
shlq $0x4, %rdx
addq %rdx, %rax
addq $0xc, %rax
xorl %edx, %edx
xorl %esi, %esi
movl (%rax,%rdx), %edi
notl %edi
shrl $0x1f, %edi
addl %edi, %esi
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x4316
xorl %eax, %eax
cmpl $0x1, %esi
setne %al
leal (%rax,%rax,2), %ebp
jmp 0x4349
movl $0x1, %ebp
jmp 0x4349
movl $0x2, %ebp
jmp 0x4349
movl $0x3, %ebp
testl %ebp, %ebp
jne 0x439e
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
jne 0x437b
leaq (%rax,%rax), %rsi
testq %rax, %rax
movl $0x2, %eax
cmoveq %rax, %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x3, %rsi
callq 0x1180
movq %rax, 0x10(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movq %r12, (%rcx,%rax,8)
leal -0x1(%r15), %eax
cmpl $0x1, %r15d
movl %eax, %r15d
jg 0x4272
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/hit.c
// Function: ma_hit_mark_unused
void ma_hit_mark_unused(sdict_t *d, size_t n, const ma_hit_t *a)
{
	size_t i;
	for (i = 0; i < d->n_seq; ++i)
		d->seq[i].aux = 0;
	for (i = 0; i < n; ++i)
		d->seq[a[i].qns>>32].aux = d->seq[a[i].tn].aux = 1;
	for (i = 0; i < d->n_seq; ++i) {
		sd_seq_t *s = &d->seq[i];
		if (!s->aux) s->del = 1;
		else s->aux = 0;
	}
}

// Assembly:
cmpl $0x0, (%rdi)
je 0x5619
movl $0xc, %eax
xorl %ecx, %ecx
movq 0x8(%rdi), %r8
andl $0x80000000, (%r8,%rax) # imm = 0x80000000
incq %rcx
movl (%rdi), %r8d
addq $0x10, %rax
cmpq %r8, %rcx
jb 0x55fe
testq %rsi, %rsi
je 0x5664
movl $0x80000000, %eax       # imm = 0x80000000
movq 0x8(%rdi), %rcx
movl 0xc(%rdx), %r8d
shlq $0x4, %r8
movl 0xc(%rcx,%r8), %r9d
andl %eax, %r9d
incl %r9d
movl %r9d, 0xc(%rcx,%r8)
movq 0x8(%rdi), %rcx
movl 0x4(%rdx), %r8d
shlq $0x4, %r8
movl 0xc(%rcx,%r8), %r9d
andl %eax, %r9d
incl %r9d
movl %r9d, 0xc(%rcx,%r8)
addq $0x20, %rdx
decq %rsi
jne 0x5623
cmpl $0x0, (%rdi)
je 0x56a0
movl $0xc, %eax
xorl %ecx, %ecx
movl $0x80000000, %edx       # imm = 0x80000000
movq 0x8(%rdi), %rsi
movl (%rsi,%rax), %r8d
movl %r8d, %r9d
andl %edx, %r9d
testl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
cmovel %edx, %r9d
movl %r9d, (%rsi,%rax)
incq %rcx
movl (%rdi), %esi
addq $0x10, %rax
cmpq %rsi, %rcx
jb 0x5675
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asm.c
// Function: ma_sg_print
void ma_sg_print(const asg_t *g, const sdict_t *d, const ma_sub_t *sub, FILE *fp)
{
	uint32_t i;
	for (i = 0; i < g->n_arc; ++i) {
		const asg_arc_t *p = &g->arc[i];
		if (sub) {
			const ma_sub_t *sq = &sub[p->ul>>33], *st = &sub[p->v>>1];
			fprintf(fp, "L\t%s:%d-%d\t%c\t%s:%d-%d\t%c\t%d:\tL1:i:%d\n", d->seq[p->ul>>33].name, sq->s + 1, sq->e, "+-"[p->ul>>32&1],
					d->seq[p->v>>1].name, st->s + 1, st->e, "+-"[p->v&1], p->ol, (uint32_t)p->ul);
		} else {
			fprintf(fp, "L\t%s\t%c\t%s\t%c\t%d:\tL1:i:%d\n", d->seq[p->ul>>33].name, "+-"[p->ul>>32&1],
					d->seq[p->v>>1].name, "+-"[p->v&1], p->ol, (uint32_t)p->ul);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
testl $0x7fffffff, 0x4(%rdi)  # imm = 0x7FFFFFFF
je 0x6922
movq %rdx, %r12
movq %rdi, %rbx
movl $0xc, %r13d
xorl %r15d, %r15d
movq %rdi, 0x20(%rsp)
movq 0x8(%rbx), %rax
testq %r12, %r12
je 0x6895
movq -0xc(%rax,%r13), %r11
movq %r11, %rdx
shrq $0x21, %rdx
movl -0x4(%rax,%r13), %esi
movl %esi, %ebx
shrl %ebx
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %r9
movq %r9, 0x30(%rsp)
movl (%r12,%rdx,8), %ecx
movl 0x4(%r12,%rdx,8), %edi
movl %edi, 0xc(%rsp)
shlq $0x4, %rdx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
andl %r8d, %ecx
incl %ecx
btq $0x20, %r11
leaq 0x3d77(%rip), %r10      # 0xa5a0
movq %r10, %rdi
adcq $0x0, %rdi
movq (%r9,%rdx), %rdx
movsbl (%rdi), %r9d
movl (%r12,%rbx,8), %ebp
movl 0x4(%r12,%rbx,8), %edi
movq %rdi, 0x28(%rsp)
shlq $0x4, %rbx
andl %r8d, %ebp
incl %ebp
andl $0x1, %esi
movsbl (%rsi,%r10), %r14d
movl (%rax,%r13), %r10d
andl %r8d, %r10d
movq 0x18(%rsp), %rdi
leaq 0x3d0f(%rip), %rsi      # 0xa579
movl 0xc(%rsp), %r8d
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %r14
pushq 0x40(%rsp)
pushq %rbp
movq 0x58(%rsp), %r10
pushq (%r10,%rbx)
movq 0x50(%rsp), %rbx
callq 0x1120
addq $0x30, %rsp
jmp 0x690a
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq -0xc(%rax,%r13), %r10
movq %r10, %rcx
shrq $0x1d, %rcx
andq $-0x10, %rcx
movq (%rsi,%rcx), %rdx
btq $0x20, %r10
leaq 0x3ce2(%rip), %r9       # 0xa5a0
movq %r9, %rcx
adcq $0x0, %rcx
movsbl (%rcx), %ecx
movl -0x4(%rax,%r13), %edi
movl %edi, %r8d
shrl %r8d
shlq $0x4, %r8
movq (%rsi,%r8), %r8
andl $0x1, %edi
movsbl (%rdi,%r9), %r9d
movl (%rax,%r13), %r11d
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl %eax, %r11d
movq 0x18(%rsp), %rdi
leaq 0x3ca8(%rip), %rsi      # 0xa5a3
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x1120
addq $0x10, %rsp
incq %r15
movl 0x4(%rbx), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq $0x10, %r13
cmpq %rax, %r15
jb 0x67d1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/miniasm/asm.c
// Function: ma_ug_destroy
KDQ_INIT(uint64_t)

void ma_ug_destroy(ma_ug_t *ug)
{
	uint32_t i;
	if (ug == 0) return;
	for (i = 0; i < ug->u.n; ++i) {
		free(ug->u.a[i].a);
		free(ug->u.a[i].s);
	}
	free(ug->u.a);
	asg_destroy(ug->g);
	free(ug);
}

// Assembly:
testq %rdi, %rdi
je 0x6995
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x6977
movl $0x1, %ebp
xorl %eax, %eax
movq 0x10(%rbx), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,4), %r14
movq 0x18(%rcx,%r14), %rdi
callq 0x1040
movq 0x10(%rbx), %rax
movq 0x20(%rax,%r14), %rdi
callq 0x1040
movl %ebp, %eax
incl %ebp
cmpq %rax, (%rbx)
ja 0x694a
movq 0x10(%rbx), %rdi
callq 0x1040
movq 0x18(%rbx), %rdi
callq 0x3f87
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/cf.c
// Function: cf_open
color_file_t *cf_open(const char *fn)
{
	gzFile fp = gzopen(fn, "r");
	if (fp == 0) return 0;
	color_file_t *pf = (color_file_t*) calloc(1, sizeof(color_file_t));
	pf->fp = ks_init(fp);
	return pf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2108(%rip), %rsi      # 0xa05c
callq 0x11a0
testq %rax, %rax
je 0x7fab
movq %rax, %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %rax, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %rax, %r15
movq %r14, 0x10(%rax)
movl 0x8(%rax), %eax
andl $0x3, %eax
orl $0x40000, %eax          # imm = 0x40000
movl %eax, 0x8(%r15)
movl $0x10000, %edi          # imm = 0x10000
callq 0x1160
movq %rax, 0x18(%r15)
movq %r15, (%rbx)
jmp 0x7fad
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/cf.c
// Function: cf_close
int cf_close(color_file_t *pf)
{
	if (pf == 0) return 0;
	free(pf->buf.s);
	kstream_t *ks = (kstream_t*) pf->fp;
	gzclose(ks->f);
	ks_destroy(ks);
	free(pf);
	return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x7ffc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040
movq (%rbx), %r14
movq 0x10(%r14), %rdi
callq 0x1030
testq %r14, %r14
je 0x7fed
movq 0x18(%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1040
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/color.c
// Function: rs_sort_color
void km_cf_print(sdict_t *d, km_color_t *c)
{
	for (size_t i = 0; i < d->n_seq; ++i) {
		if (c[i].c1 == 0) continue;
		else if (c[i].c2 == 0) printf("%s\t%llu\n", d->seq[i].name, c[i].c1);
		else printf("%s\t%llu\t%llu\n", d->seq[i].name, c[i].c1, c[i].c2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, -0x30(%rbp)
movl %edx, %ecx
movl $0x1, %eax
movl %edx, -0x2c(%rbp)
shll %cl, %eax
leal -0x1(%rax), %edx
movq %rax, %rcx
shlq $0x4, %rcx
movq %rsp, %r15
subq %rcx, %r15
movq %r15, %rsp
movslq %eax, %r12
shlq $0x4, %r12
leaq (%r15,%r12), %rax
xorl %ecx, %ecx
movq %rdi, 0x8(%r15,%rcx)
movq %rdi, (%r15,%rcx)
addq $0x10, %rcx
cmpq %rcx, %r12
jne 0x8327
movl -0x30(%rbp), %ecx
movslq %edx, %rdx
cmpq %rsi, %rdi
je 0x8363
movq %rdi, %r8
movq (%r8), %r9
shrq %cl, %r9
andq %rdx, %r9
shlq $0x4, %r9
addq $0x10, 0x8(%r15,%r9)
addq $0x10, %r8
cmpq %rsi, %r8
jne 0x8347
cmpl $0x0, -0x2c(%rbp)
je 0x838b
movl $0x10, %esi
movq -0x8(%r15,%rsi), %r8
movq %r8, %r9
subq %rdi, %r9
addq %r9, 0x8(%r15,%rsi)
movq %r8, (%r15,%rsi)
addq $0x10, %rsi
cmpq %rsi, %r12
jne 0x836e
movq %r15, %rsi
movq (%rsi), %r10
cmpq 0x8(%rsi), %r10
je 0x83f9
movq (%r10), %r8
movq %r8, %r9
shrq %cl, %r9
andq %rdx, %r9
shlq $0x4, %r9
addq %r15, %r9
cmpq %rsi, %r9
je 0x83ff
movq 0x8(%r10), %r10
movq %r8, %r11
movq %r10, %r13
movq (%r9), %r14
movq (%r14), %r8
movq 0x8(%r14), %r10
leaq 0x10(%r14), %rbx
movq %rbx, (%r9)
movq %r11, (%r14)
movq %r13, 0x8(%r14)
movq %r8, %r9
shrq %cl, %r9
andq %rdx, %r9
shlq $0x4, %r9
addq %r15, %r9
cmpq %rsi, %r9
jne 0x83b3
movq (%rsi), %r9
leaq 0x10(%r9), %r11
movq %r11, (%rsi)
movq %r8, (%r9)
movq %r10, 0x8(%r9)
jmp 0x8406
addq $0x10, %rsi
jmp 0x8406
addq $0x10, %r10
movq %r10, (%rsi)
cmpq %rax, %rsi
jne 0x838e
movq %rdi, (%r15)
cmpl $0x0, -0x2c(%rbp)
je 0x842b
movl $0x10, %eax
movq -0x8(%r15,%rax), %rcx
movq %rcx, (%r15,%rax)
addq $0x10, %rax
cmpq %rax, %r12
jne 0x8419
cmpl $0x0, -0x30(%rbp)
je 0x8477
xorl %r13d, %r13d
movl -0x30(%rbp), %ebx
subl -0x2c(%rbp), %ebx
cmovlel %r13d, %ebx
movq (%r15,%r13), %rdi
movq 0x8(%r15,%r13), %rsi
movq %rsi, %rax
subq %rdi, %rax
sarq $0x4, %rax
cmpq $0x41, %rax
jl 0x8463
movl -0x2c(%rbp), %edx
movl %ebx, %ecx
callq 0x82ea
jmp 0x846e
cmpq $0x2, %rax
jl 0x846e
callq 0x8290
addq $0x10, %r13
cmpq %r13, %r12
jne 0x843e
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/color.c
// Function: km_exclude
sdict_t *km_exclude(const char *fn, uint64_t color)
{
	color_file_t *fp;
	fp = cf_open(fn);
	if (!fp) {
		fprintf(stderr, "[E::%s] could not open color file %s\n", __func__, fn);
		exit(1);
	}

	sdict_t *d = sd_init();
	color_rec_t r;
	while (color_read(fp, &r) >= 0) {
		if (r.c1 <= color && r.c2 >= color)
			sd_put(d, r.qn, (uint32_t) r.c1);
	}
	cf_close(fp);
	fprintf(stderr, "[M::%s] dropped %d colored reads\n", __func__, d->n_seq);
	return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7f48
testq %rax, %rax
je 0x8558
movq %rsp, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2626
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x26b9
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/color.c
// Function: km_intervalize
km_color_t *km_intervalize(km_multicolor_t *colors, size_t n_reads)
{
	km_color_t *intervals = (km_color_t*) calloc(n_reads, sizeof(km_color_t));
	for (size_t i = 0; i < n_reads; i++) {
		if (colors[i].n == 0) continue;
		// TODO: Combine with color merging
		uint64_t min = colors[i].a[0], max = colors[i].a[0];
		for (size_t j = 1; j < colors[i].n; j++) {
			min = (colors[i].a[j] < min) ? colors[i].a[j] : min;
			max = (colors[i].a[j] > max) ? colors[i].a[j] : max;
		}
		intervals[i].c1 = min;
		intervals[i].c2 = max;
	}
	return intervals;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x10f0
testq %rbx, %rbx
je 0x8614
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rdx
movq (%r14,%rdx,8), %rsi
testq %rsi, %rsi
je 0x860c
leaq (%r14,%rdx,8), %rdx
movq 0x10(%rdx), %rdi
movq (%rdi), %rdx
cmpq $0x1, %rsi
jne 0x85d9
movq %rdx, %r8
jmp 0x85fc
movl $0x1, %r9d
movq %rdx, %r8
movq (%rdi,%r9,8), %r10
cmpq %r8, %r10
cmovbq %r10, %r8
cmpq %rdx, %r10
cmovaq %r10, %rdx
incq %r9
cmpq %r9, %rsi
jne 0x85e2
movq %rcx, %rsi
shlq $0x4, %rsi
movq %r8, (%rax,%rsi)
movq %rdx, 0x8(%rax,%rsi)
incq %rcx
cmpq %rbx, %rcx
jne 0x85b6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/index.c
// Function: km_idx_destroy
void km_idx_destroy(km_idx_t *idx)
{
	if (idx == 0) return;
	for (uint32_t i = 0; i < idx->d->n_seq; i++) {
		for (uint32_t j = 0; j < idx->targets[i].n_bins; j++)
			free(idx->targets[i].bins[j].a);
		free(idx->targets[i].bins);
	}
	free(idx->targets);
	sd_destroy(idx->d);
	free(idx);
}

// Assembly:
testq %rdi, %rdi
je 0x86b5
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax)
je 0x8692
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
cmpl $0x0, (%rax,%r15)
je 0x867a
movl $0x10, %r12d
xorl %r13d, %r13d
movq 0x8(%rax,%r15), %rax
movq (%rax,%r12), %rdi
callq 0x1040
incq %r13
movq 0x10(%rbx), %rax
movl (%rax,%r15), %ecx
addq $0x18, %r12
cmpq %rcx, %r13
jb 0x8658
movq 0x8(%rax,%r15), %rdi
callq 0x1040
incq %r14
movq 0x8(%rbx), %rax
movl (%rax), %eax
cmpq %rax, %r14
jb 0x863d
movq 0x10(%rbx), %rdi
callq 0x1040
movq 0x8(%rbx), %rdi
callq 0x30fb
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/index.c
// Function: km_pileup
km_hit_v km_pileup(km_idx_t *idx, const char *contig, const uint32_t pos)
{
	km_hit_v v = {0,0,0};

	int32_t tid = sd_get(idx->d, contig);
	size_t id = pos / idx->length;
	if (tid < 0 || id >= idx->targets[tid].n_bins) return v;
	km_hit_v *bin = &idx->targets[tid].bins[id];
	for (size_t i = 0; i < bin->n; i++) {
		const km_hit_t h = bin->a[i];
		if (h.s > pos || h.e < pos) continue;
		kv_push(km_hit_t, v, h);
	}
	return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x3428
movl %eax, %ecx
movl %r15d, %eax
xorl %edx, %edx
divl (%r14)
testl %ecx, %ecx
js 0x87dc
movq 0x10(%r14), %rdx
movl %ecx, %ecx
shlq $0x4, %rcx
cmpl (%rdx,%rcx), %eax
jae 0x87dc
addq %rcx, %rdx
movq 0x8(%rdx), %rcx
leaq (%rax,%rax,2), %rax
movq (%rbx), %r8
cmpq $0x0, (%rcx,%rax,8)
je 0x87d9
leaq (%rcx,%rax,8), %r14
movq 0x8(%rbx), %rcx
movq %rbx, 0x8(%rsp)
movq 0x10(%rbx), %rax
movl $0x8, %r12d
xorl %r13d, %r13d
movl %r15d, (%rsp)
movq 0x10(%r14), %rdx
movl -0x4(%rdx,%r12), %ebx
cmpl %r15d, %ebx
seta %sil
movl (%rdx,%r12), %ebp
cmpl %r15d, %ebp
setb %dil
orb %sil, %dil
jne 0x87bc
movl -0x8(%rdx,%r12), %esi
cmpq %rcx, %r8
jne 0x87aa
leaq (%rcx,%rcx), %r15
testq %rcx, %rcx
movl $0x2, %ecx
cmoveq %rcx, %r15
leaq (,%r15,4), %rcx
movl %esi, 0x4(%rsp)
leaq (%rcx,%rcx,2), %rsi
movq %rax, %rdi
movq %r8, 0x10(%rsp)
callq 0x1180
movl 0x4(%rsp), %esi
movq 0x10(%rsp), %r8
movq %r15, %rcx
movl (%rsp), %r15d
leaq (%r8,%r8,2), %rdx
incq %r8
movl %esi, (%rax,%rdx,4)
movl %ebx, 0x4(%rax,%rdx,4)
movl %ebp, 0x8(%rax,%rdx,4)
incq %r13
addq $0xc, %r12
cmpq (%r14), %r13
jb 0x8743
movq 0x8(%rsp), %rbx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %r8, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/marker.c
// Function: marker_open
marker_file_t *marker_open(const char *fn)
{
	gzFile fp = gzopen(fn, "r");
	if (fp == 0) return 0;
	marker_file_t *pf = (marker_file_t *) calloc(1, sizeof(marker_file_t));
	pf->fp = ks_init(fp);
	return pf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x13e4(%rip), %rsi      # 0xa05c
callq 0x11a0
testq %rax, %rax
je 0x8ccf
movq %rax, %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %rax, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %rax, %r15
movq %r14, 0x10(%rax)
movl 0x8(%rax), %eax
andl $0x3, %eax
orl $0x40000, %eax          # imm = 0x40000
movl %eax, 0x8(%r15)
movl $0x10000, %edi          # imm = 0x10000
callq 0x1160
movq %rax, 0x18(%r15)
movq %r15, (%rbx)
jmp 0x8cd1
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rikuu[P]kermit/marker.c
// Function: marker_close
int marker_close(marker_file_t *pf)
{
	if (pf == 0) return 0;
	free(pf->buf.s);
	kstream_t *ks = (kstream_t *) pf->fp;
	gzclose(ks->f);
	ks_destroy(ks);
	free(pf);
	return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x8d20
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040
movq (%rbx), %r14
movq 0x10(%r14), %rdi
callq 0x1030
testq %r14, %r14
je 0x8d11
movq 0x18(%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1040
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: SD_print_sub
void SD_print_sub(pSD psd, FILE* fp) {
    fprintf(stderr, "%-10s %-12s %-10s %-10s %6s %6s %7s\n",
        "lexeme", "type", "scope", "lines", "level", "width", "offset");
    for(pSTEntry node = psd->first_entry; node != NULL; node = node->next) {
        pSTEntry_print_sub(node, stderr);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x11820(%rip), %r14     # 0x14ff8
movq (%r14), %rdi
subq $0x8, %rsp
leaq 0xba52(%rip), %r10      # 0xf238
leaq 0xba45(%rip), %r11      # 0xf232
leaq 0xba38(%rip), %r15      # 0xf22c
leaq 0xb9f9(%rip), %rsi      # 0xf1f4
leaq 0xba17(%rip), %rdx      # 0xf219
leaq 0xb03f(%rip), %rcx      # 0xe848
leaq 0xba10(%rip), %r8       # 0xf220
leaq 0xba0f(%rip), %r9       # 0xf226
xorl %eax, %eax
pushq %r10
pushq %r11
pushq %r15
callq 0x3140
addq $0x20, %rsp
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
je 0x3842
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x9724
movq 0x20(%rbx), %rbx
jmp 0x382c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_hmap_get_node
ITYPED(hmap_node)* ITYPED(hmap_get_node)(KTYPE k, VTYPE v, ITYPED(hmap_node)* next)
{
    ITYPED(hmap_node)* n = malloc(sizeof(ITYPED(hmap_node)));
    n->key = k;
    n->value = v;
    n->next = next;
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl $0x18, %edi
callq 0x3150
movq %r15, 0x8(%rax)
movl %r14d, 0x10(%rax)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/./util/hmap.gen.c
// Function: ST_hmap_destroy_chain
void ITYPED(hmap_destroy_chain)(ITYPED(hmap_node)* p, bool destroy_key, bool destroy_value)
{
    ITYPED(hmap_node)* p2 = NULL;
    while(p != NULL)
    {
        p2 = p->next;
        p->next = NULL;
        if(destroy_key)
            KTYPED(destroy)(p->key);
        if(destroy_value)
            VTYPED(destroy)(p->value);
        free(p);
        p = p2;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x9882
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movq (%r15), %r12
movq $0x0, (%r15)
testb %r14b, %r14b
je 0x985d
movq 0x8(%r15), %rdi
callq 0x4728
testb %bl, %bl
je 0x986a
movq 0x10(%r15), %rdi
callq 0x3030
movq %r15, %rdi
callq 0x3030
movq %r12, %r15
testq %r12, %r12
jne 0x9845
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_hmap_init
void ITYPED(hmap_init)(ITYPED(hmap)* phmap, int capacity, bool destroy_key)
{
#ifdef LOG_MEM
    fprintf(stderr, "Called %s(%p, %d, %d)\n", __func__, (void*)phmap, capacity, destroy_key);
#endif
    phmap->plist = calloc(capacity, sizeof(ITYPED(hmap_node)*));
    phmap->capacity = capacity;
    phmap->size = 0;
    phmap->destroy_key = destroy_key;
    phmap->destroy_value = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movslq %esi, %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x3120
movq %rax, (%r14)
movl %r15d, 0x8(%r14)
movl $0x0, 0xc(%r14)
movb %bl, 0x10(%r14)
movb $0x1, 0x11(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_hmap_clear
void ITYPED(hmap_clear)(ITYPED(hmap)* phmap)
{
    int i;
    for(i=0; i < (phmap->capacity); ++i) {
        ITYPED(hmap_destroy_chain)(phmap->plist[i], phmap->destroy_key, phmap->destroy_value);
        phmap->plist[i] = NULL;
    }
    free(phmap->plist);
    phmap->plist = NULL;
    phmap->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x3f15
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
movzbl 0x10(%rbx), %esi
movzbl 0x11(%rbx), %edx
callq 0x3e3f
movq (%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x3eea
movq (%rbx), %rdi
callq 0x3030
movq $0x0, (%rbx)
movl $0x0, 0xc(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_hmap_query
ITYPED(hmap_node)* ITYPED(hmap_query)(ITYPED(hmap)* phmap, KTYPE k)
{
    unsigned h = KTYPED(hash)(k) % (phmap->capacity);
    ITYPED(hmap_node)* n = phmap->plist[h];
    while(n != NULL && !(KTYPED(equals)(n->key, k)))
        n = n->next;
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x46f6
xorl %edx, %edx
divl 0x8(%r15)
movl %edx, %r14d
shlq $0x3, %r14
addq (%r15), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x3f8c
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x46e6
testb %al, %al
je 0x3f74
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_hmap_get
VTYPE ITYPED(hmap_get)(ITYPED(hmap)* phmap, KTYPE k)
{
    ITYPED(hmap_node)* n = ITYPED(hmap_query)(phmap, k);
    if(n == NULL) {
        fprintf(stderr, "KeyError: ");
        KTYPED(print)(k, stderr);
        fprintf(stderr, "\n");
        abort();
    }
    return n->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x3f4c
testq %rax, %rax
je 0x3fb7
movl 0x10(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x31f0
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_hmap_insert
ITYPED(hmap_node)* ITYPED(hmap_insert)(ITYPED(hmap)* phmap, KTYPE k, VTYPE v)
{
    const int lf_num = 3, lf_den = 4;
    if(lf_den * (phmap->size+1) > lf_num * phmap->capacity)
        ITYPED(hmap_rehash)(phmap, 2 * (phmap->capacity));
    unsigned h = KTYPED(hash)(k) % (phmap->capacity);
    ITYPED(hmap_node)** plist = phmap->plist;
    ITYPED(hmap_node)* n = plist[h];
    while(n != NULL && !(KTYPED(equals)(n->key, k)))
        n = n->next;
    if(n == NULL) {
        (phmap->size)++;
        n = plist[h] = ITYPED(hmap_get_node)(k, v, plist[h]);
    }
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %eax
leal 0x4(,%rax,4), %eax
leal (%rsi,%rsi,2), %ecx
cmpl %ecx, %eax
jle 0x3ff3
addl %esi, %esi
movq %r15, %rdi
callq 0x405e
movq %r14, %rdi
callq 0x46f6
xorl %edx, %edx
divl 0x8(%r15)
movl %edx, %r12d
shlq $0x3, %r12
addq (%r15), %r12
movq %r12, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x4029
movq 0x8(%r13), %rdi
movq %r14, %rsi
callq 0x46e6
testb %al, %al
je 0x400e
jmp 0x404c
incl 0xc(%r15)
movq (%r12), %r15
movl $0x18, %edi
callq 0x3150
movq %rax, %r13
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq %r15, (%rax)
movq %rax, (%r12)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_hmap_rehash
void ITYPED(hmap_rehash)(ITYPED(hmap)* phmap, int new_capacity)
{
    int i;
    ITYPED(hmap_node)** plist2 = calloc(new_capacity, sizeof(ITYPED(hmap_node)*));
    for(i=0; i<(phmap->capacity); ++i) {
        ITYPED(hmap_node)* n = phmap->plist[i];
        while(n != NULL) {
            unsigned h = KTYPED(hash)(n->key) % new_capacity;
            plist2[h] = ITYPED(hmap_get_node)(n->key, n->value, plist2[h]);
            n = n->next;
        }
        ITYPED(hmap_destroy_chain)(phmap->plist[i], false, false);
        phmap->plist[i] = NULL;
    }

    free(phmap->plist);
    phmap->plist = plist2;
    phmap->capacity = new_capacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r14
movslq %esi, %rdi
movl $0x8, %esi
callq 0x3120
movq %rax, %r12
cmpl $0x0, 0x8(%r14)
jle 0x4134
xorl %r13d, %r13d
movl %r15d, -0x2c(%rbp)
movq %r14, -0x38(%rbp)
movq (%r14), %rax
movq %r13, -0x40(%rbp)
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x40ee
movq 0x8(%r14), %rdi
callq 0x46f6
xorl %edx, %edx
divl %r15d
movl %edx, %ebx
movq 0x8(%r14), %r13
movl 0x10(%r14), %eax
movl %eax, -0x30(%rbp)
movq (%r12,%rbx,8), %r15
movl $0x18, %edi
callq 0x3150
movq %r13, 0x8(%rax)
movl -0x30(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq %r15, (%rax)
movl -0x2c(%rbp), %r15d
movq %rax, (%r12,%rbx,8)
movq (%r14), %r14
jmp 0x40a6
movq -0x38(%rbp), %r14
movq (%r14), %rax
movq -0x40(%rbp), %r13
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x4119
movq (%rdi), %rbx
movq $0x0, (%rdi)
callq 0x3030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x4102
movq (%r14), %rax
movq $0x0, (%rax,%r13,8)
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x409b
movq (%r14), %rdi
callq 0x3030
movq %r12, (%r14)
movl %r15d, 0x8(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/./util/hmap.gen.c
// Function: ST_hmap_update
ITYPED(hmap_node)* ITYPED(hmap_update)(ITYPED(hmap)* phmap, KTYPE k, VTYPE v)
{
    int old_size = phmap->size;
    ITYPED(hmap_node)* n = ITYPED(hmap_insert)(phmap, k, v);
    if(phmap->size == old_size) {
        if(phmap->destroy_value)
            VTYPED(destroy)(n->value);
        n->value = v;
    }
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movl 0xc(%rdi), %r12d
callq 0x99ae
movq %rax, %r14
cmpl %r12d, 0xc(%r15)
jne 0x9b75
cmpb $0x1, 0x11(%r15)
jne 0x9b71
movq 0x10(%r14), %rdi
callq 0x3030
movq %rbx, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/./util/hmap.gen.c
// Function: vptr_pMN_hmap_print
void ITYPED(hmap_print)(ITYPED(hmap)* phmap, FILE* fp) {
    int capacity = phmap->capacity;
    ITYPED(hmap_node)** plist = phmap->plist;
    ITYPED(hmap_node)* n = NULL;
    fprintf(fp, "hmap(size=%d, capacity=%d):\n", phmap->size, capacity);
    for(int i=0; i<capacity; ++i) {
        for(n = plist[i]; n != NULL; n = n->next) {
            fprintf(fp, "  ");
            KTYPED(print)(n->key, fp);
            fprintf(fp, ": ");
            VTYPED(print)(n->value, fp);
            fprintf(fp, "\n");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movslq 0x8(%rdi), %r14
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
movl 0xc(%rdi), %edx
leaq 0x3a6a(%rip), %rsi      # 0xe00f
movq %rbx, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3140
movq %r14, -0x38(%rbp)
testq %r14, %r14
jle 0xa65c
leaq 0x481e(%rip), %r15      # 0xede4
leaq 0x3a3f(%rip), %r12      # 0xe00c
leaq 0x54ec(%rip), %r13      # 0xfac0
xorl %ecx, %ecx
movq -0x30(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0xa64b
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x31d0
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x4747
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x31d0
movq 0x10(%r14), %rax
movq 0x50(%rax), %rdx
movl 0xc(%rax), %ecx
movl 0x10(%rax), %r8d
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x3140
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3110
movq (%r14), %r14
jmp 0xa5e2
movq -0x40(%rbp), %rcx
incq %rcx
cmpq -0x38(%rbp), %rcx
jne 0xa5d6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/pch.c
// Function: pch_hash
unsigned pch_hash(pch str)
{
    unsigned res = 0;
    for(int i=0; str[i] != '\0'; ++i)
        res = res * 307 + (int)(str[i]);
    //fprintf(stderr, "hash(%s) = %u\n", str, res);
    return res;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x471b
pushq %rbp
movq %rsp, %rbp
incq %rdi
xorl %eax, %eax
movsbl %cl, %ecx
imull $0x133, %eax, %eax      # imm = 0x133
addl %ecx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x4705
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/stack.gen.c
// Function: int_get_stack_node
TYPED(stack_node)* TYPED(get_stack_node)(TYPE value, TYPED(stack_node)* next)
{
    TYPED(stack_node)* sn = malloc(sizeof(TYPED(stack_node)));
    sn->value = value;
    sn->next = next;
    return sn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
movl $0x10, %edi
callq 0x3150
movl %r14d, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/stack.gen.c
// Function: int_stack_clear
void TYPED(stack_clear)(TYPED(stack) *ps)
{
    TYPED(stack_node) *p = ps->top, *todel = NULL;
    while(p != NULL)
    {
        todel = p;
        p = p->next;
        todel->next = NULL;
        TYPED(destroy)(todel->value);
        free(todel);
    }
    ps->top = NULL;
    ps->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x47d4
movq 0x8(%r14), %r15
movq $0x0, 0x8(%r14)
movl (%r14), %edi
callq 0x4924
movq %r14, %rdi
callq 0x3030
movq %r15, %r14
testq %r15, %r15
jne 0x47b0
movq $0x0, (%rbx)
movl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/stack.gen.c
// Function: int_stack_push
void TYPED(stack_push)(TYPED(stack)* ps, TYPE value)
{
    /*
    fprintf(stderr, "Pushing: ");
    TYPED(print)(value,stderr);
    fprintf(stderr, "\n");
    */
    if(ps->size > 100){
        fprintf(stderr,"stack size exceeded limit!\n");
        exit(1);
    }
    ps->top = TYPED(get_stack_node)(value, ps->top);
    (ps->size)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x8(%rdi), %r15d
cmpl $0x65, %r15d
jge 0x484b
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %r12
movl $0x10, %edi
callq 0x3150
movl %r14d, (%rax)
movq %r12, 0x8(%rax)
movq %rax, (%rbx)
incl %r15d
movl %r15d, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3272
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/stack.gen.c
// Function: int_stack_print
void TYPED(stack_print)(TYPED(stack)* ps, FILE* fp)
{
    fprintf(fp, "[");
    TYPED(stack_node)* p = ps->top;
    if(p != NULL)
    {
        TYPED(print)(p->value, fp);
        p = p->next;
        while(p != NULL)
        {
            fprintf(fp, ", ");
            TYPED(print)(p->value, fp);
            p = p->next;
        }
    }
    fprintf(fp, "]\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5b, %edi
callq 0x3110
movq (%r14), %r14
testq %r14, %r14
je 0x48b6
movl (%r14), %edi
movq %rbx, %rsi
callq 0x493d
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x48b6
leaq 0xa582(%rip), %r14      # 0xee0f
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x31d0
movl (%r15), %edi
movq %rbx, %rsi
callq 0x493d
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x488d
leaq 0x978e(%rip), %rdi      # 0xe04b
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31d0
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/util/stack.gen.c
// Function: int_stack_pop
TYPE TYPED(stack_pop)(TYPED(stack)* ps)
{
    if(ps->size == 0)
        fprintf(stderr, "pop called on empty stack\n");
    else
    {
        TYPED(stack_node)* tmp = ps->top;
        ps->top = tmp->next;
        TYPE v = tmp->value;
        free(tmp);
        (ps->size)--;
        /*
        fprintf(stderr, "Popping: ");
        TYPED(print)(v, stderr);
        fprintf(stderr, "\n");
        */
        return v;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x8(%rdi)
je 0x491d
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
movl (%rdi), %r14d
callq 0x3030
decl 0x8(%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x32c9
jmp 0x4915