LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/miniasm/asg.c
// Function: asg_bub_backtrack
static void asg_bub_backtrack(asg_t *g, uint32_t v0, buf_t *b)
{
	uint32_t i, v;
	assert(b->S.n == 1);
	for (i = 0; i < b->b.n; ++i)
		g->seq[b->b.a[i]>>1].del = 1;
	for (i = 0; i < b->e.n; ++i) {
		asg_arc_t *a = &g->arc[b->e.a[i]];
		a->del = 1;
		asg_arc_del(g, a->v^1, a->ul>>32^1, 1);
	}
	v = b->S.a[0];
	do {
		uint32_t u = b->a[v].p; // u->v
		g->seq[v>>1].del = 0;
		asg_arc_del(g, u, v, 0);
		asg_arc_del(g, v^1, u^1, 0);
		v = u;
	} while (v != v0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x52a0
jmp 0x52bf
leaq 0x9fb4(%rip), %rdi      # 0xf25b
leaq 0x9ecb(%rip), %rsi      # 0xf179
movl $0x155, %edx            # imm = 0x155
leaq 0x9fad(%rip), %rcx      # 0xf267
callq 0x10b0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x530a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x48(%rcx), %rcx
movl -0x1c(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
shrl %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
orl $0x80000000, %edx       # imm = 0x80000000
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x52c6
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x5389
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x60(%rcx), %rcx
movl -0x1c(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
xorl $0x1, %esi
movq -0x28(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
xorq $0x1, %rax
movl %eax, %edx
movl $0x1, %ecx
callq 0x47e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5311
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x20(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
orl $0x0, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x20(%rbp), %edx
xorl %ecx, %ecx
callq 0x47e0
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
xorl $0x1, %esi
movl -0x2c(%rbp), %edx
xorl $0x1, %edx
xorl %ecx, %ecx
callq 0x47e0
movl -0x2c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x5396
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/miniasm/common.c
// Function: ma_opt_init
void ma_opt_init(ma_opt_t *opt)
{
	opt->min_span = 2000;
	opt->min_match = 100;
	opt->min_dp = 3;
	opt->min_iden = .05;

	opt->max_hang = 1000;
	opt->min_ovlp = opt->min_span;
	opt->int_frac = .8;

	opt->gap_fuzz = 1000;
	opt->n_rounds = 2;
	opt->bub_dist = 50000;
	opt->max_ext = 4;
	opt->min_ovlp_drop_ratio = .5;
	opt->max_ovlp_drop_ratio = .7;
	opt->final_ovlp_drop_ratio = .8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x7d0, (%rax)          # imm = 0x7D0
movq -0x8(%rbp), %rax
movl $0x64, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x8(%rax)
movq -0x8(%rbp), %rax
movss 0x9e64(%rip), %xmm0     # 0xf2a8
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x3e8, 0x10(%rax)      # imm = 0x3E8
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movss 0x9e2f(%rip), %xmm0     # 0xf29c
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x3e8, 0x1c(%rax)      # imm = 0x3E8
movq -0x8(%rbp), %rax
movl $0x2, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0xc350, 0x24(%rax)     # imm = 0xC350
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
movq -0x8(%rbp), %rax
movss 0x9dfa(%rip), %xmm0     # 0xf2a4
movss %xmm0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movss 0x9de5(%rip), %xmm0     # 0xf2a0
movss %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
movss 0x9dd0(%rip), %xmm0     # 0xf29c
movss %xmm0, 0x34(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x60b7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
andl $0x80000000, %ecx       # imm = 0x80000000
orl $0x0, %ecx
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6078
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x613b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movl 0xc(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
andl $0x80000000, %ecx       # imm = 0x80000000
orl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
shrq $0x20, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
andl $0x80000000, %ecx       # imm = 0x80000000
orl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x60bf
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x61b5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x0, %eax
jne 0x6192
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, 0xc(%rax)
jmp 0x61a5
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
andl $0x80000000, %ecx       # imm = 0x80000000
orl $0x0, %ecx
movl %ecx, 0xc(%rax)
jmp 0x61a7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6143
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/miniasm/asg.h
// Function: asg_arc_pushp
static inline asg_arc_t *asg_arc_pushp(asg_t *g)
{
	if (g->n_arc == g->m_arc) {
		g->m_arc = g->m_arc? g->m_arc<<1 : 16;
		g->arc = (asg_arc_t*)realloc(g->arc, g->m_arc * sizeof(asg_arc_t));
	}
	return &g->arc[g->n_arc++];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x83fd
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x83c6
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll %eax
movl %eax, -0xc(%rbp)
jmp 0x83d0
movl $0x10, %eax
movl %eax, -0xc(%rbp)
jmp 0x83d0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
shlq $0x4, %rsi
callq 0x1170
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x4(%rdx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %edi
addl $0x1, %edi
movl 0x4(%rdx), %esi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
andl $0x80000000, %esi       # imm = 0x80000000
orl %edi, %esi
movl %esi, 0x4(%rdx)
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8695
jmp 0x870c
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x86e9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x869c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3130
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4509(%rip), %rsi      # 0xf030
callq 0x1190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xab41
movq $0x0, -0x8(%rbp)
jmp 0xab6f
movl $0x1, %edi
movl $0x20, %esi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xab80
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%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/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xabfc
movl $0x0, -0x4(%rbp)
jmp 0xac3a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0xac50
movq -0x10(%rbp), %rdi
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/cf.c
// Function: color_read
int color_read(color_file_t *pf, color_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 = color_parse(pf->buf.l, pf->buf.s, r);
	if (ret < 0) goto file_read_more;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movl $0x2, %esi
leaq -0x20(%rbp), %rcx
callq 0xad10
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xacce
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xacfa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xad50
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xacf4
jmp 0xaca0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/cf.c
// Function: color_parse
static int color_parse(int l, char *s, color_rec_t *pr)
{
	pr->qn=0, pr->c1=0, pr->c2=0;
	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->c1 = strtol(q, &r, 10);
		else if (t == 2) pr->c2 = strtol(q, &r, 10);
		++t, q = i < l? &s[i+1] : 0;
	}
	if (t < 1) return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0xae76
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xadc6
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0xadc6
jmp 0xae68
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x30(%rbp)
jne 0xade5
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xae31
cmpl $0x1, -0x30(%rbp)
jne 0xae0a
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x1120
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xae2f
cmpl $0x2, -0x30(%rbp)
jne 0xae2d
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x1120
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xae2f
jmp 0xae31
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xae58
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0xae60
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xae60
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xad9c
cmpl $0x1, -0x30(%rbp)
jge 0xae85
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xae8c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xab10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb921
movq 0x76fd(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x3de8(%rip), %rsi      # 0xf6f1
leaq 0x3e07(%rip), %rdx      # 0xf717
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x11f0
callq 0x1490
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xac90
cmpl $0x0, %eax
jl 0xb965
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0xb963
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0xb963
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movl %eax, %edx
callq 0x15c0
jmp 0xb92a
movq -0x18(%rbp), %rdi
callq 0xabe0
movq 0x7683(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %ecx
leaq 0x3d9d(%rip), %rsi      # 0xf722
leaq 0x3d8b(%rip), %rdx      # 0xf717
movb $0x0, %al
callq 0x1110
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/color.c
// Function: km_colors_read
km_color_t *km_colors_read(const char *fn, sdict_t *d)
{
	color_file_t *fp = cf_open(fn);
	if (fp == 0) {
		fprintf(stderr, "[E::%s] could not open color file %s\n", __func__, fn);
		exit(1);
	}

	km_color_t *colors = (km_color_t*) calloc(d->n_seq, sizeof(km_color_t));
	color_rec_t r;
	size_t ones = 0, twos = 0, tot = 0;
	while (color_read(fp, &r) >= 0) {
		int32_t id = sd_get(d, r.qn);
		if (id < 0 || r.c1 == 0) continue;
		colors[id].c1 = r.c1, colors[id].c2 = r.c2;

		++tot;
		if (r.c2 - r.c1 == 0) ++ones;
		else if (r.c2 - r.c1 == 1) ++twos;
	}
	cf_close(fp);
	fprintf(stderr, "[M::%s] stored %ld colors with %ld ones, %ld twos, %ld multis, %ld uncolored\n",
		__func__, tot, ones, twos, tot-ones-twos, d->n_seq-tot);
	return colors;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xab10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb9f1
movq 0x762d(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x3d18(%rip), %rsi      # 0xf6f1
leaq 0x3d64(%rip), %rdx      # 0xf744
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x11f0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
movl $0x10, %esi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xac90
cmpl $0x0, %eax
jl 0xbaca
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1a60
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jl 0xba52
cmpq $0x0, -0x30(%rbp)
jne 0xba54
jmp 0xba1f
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movslq -0x54(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movslq -0x54(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
cmpq $0x0, %rax
jne 0xbaa9
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xbac5
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
cmpq $0x1, %rax
jne 0xbac3
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xbac5
jmp 0xba1f
movq -0x18(%rbp), %rdi
callq 0xabe0
movq 0x751e(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x48(%rbp), %r9
movq -0x50(%rbp), %r10
subq -0x40(%rbp), %r10
subq -0x48(%rbp), %r10
movq -0x10(%rbp), %rax
movl (%rax), %eax
subq -0x50(%rbp), %rax
leaq 0x3c4d(%rip), %rsi      # 0xf753
leaq 0x3c37(%rip), %rdx      # 0xf744
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1110
movq -0x20(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/color.c
// Function: km_cut_cross
int km_cut_cross(asg_t *g, km_color_t *c, int max_distance)
{
	size_t n_cross = 0;
	for (uint32_t e = 0; e < g->n_arc; ++e) {
		uint32_t v = g->arc[e].ul>>33, u = g->arc[e].v>>1;
		// if run with no propagation, we allow arcs to/from uncolored reads
		if (!COLORED(c[v]) || !COLORED(c[u])) continue;
		if (overlap(c[v], c[u], max_distance)) continue;
		g->arc[e].del = 1, ++n_cross;
	}
	fprintf(stderr, "[M::%s] removed %ld color crossing arcs\n", __func__, n_cross);
	if (n_cross)
		asg_cleanup(g);
	return n_cross;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jae 0xbc6c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
shrq $0x21, %rax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
shrl %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0xbbc9
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0xbbf2
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0xbbf4
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0xbbf4
jmp 0xbc5e
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl -0x14(%rbp), %r8d
movq (%rcx), %rdi
movq 0x8(%rcx), %rsi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0xbcb0
cmpl $0x0, %eax
je 0xbc2e
jmp 0xbc5e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xbb52
movq 0x7385(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rcx
leaq 0x3b20(%rip), %rsi      # 0xf7a1
leaq 0x3b42(%rip), %rdx      # 0xf7ca
movb $0x0, %al
callq 0x1110
cmpq $0x0, -0x20(%rbp)
je 0xbc9f
movq -0x8(%rbp), %rdi
callq 0x35d0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x10e0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xbeb5
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0xbd7f
jmp 0xbea4
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq $0x18, -0x20(%rbp), %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jae 0xbe77
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
jae 0xbe0a
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
jmp 0xbe12
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x30(%rbp), %rax
jbe 0xbe56
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0xbe5e
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xbdb5
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xbd5a
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/color.c
// Function: contains
static inline int contains(const km_color_t *a, const size_t n, const km_color_t x)
{
	// This is a simple O(n) check, we assume n to be small here
	for (size_t i = 0; i < n; i++) {
		if (a[i].c1 == x.c1 && a[i].c2 == x.c2)
			return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xc3c0
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xc3b0
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xc3b0
movl $0x1, -0x4(%rbp)
jmp 0xc3c7
jmp 0xc3b2
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc36c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/color.c
// Function: merge_colors
static km_color_t merge_colors(km_color_v colors)
{
	if (colors.n == 0) return null_color;
	// TODO: Some heuristic for chimericity
	// TODO: This is biased towards lower colors
	// Possibly merge into "chains" and take best chain
	// Then chimeric if two chains are distant
	radix_sort_color(colors.a, colors.a + colors.n);
	km_color_t result = colors.a[0];
	for (size_t i = 1; i < colors.n; i++) {
		if (overlap(result, colors.a[i], 1)) {
			result.c1 = (colors.a[i].c1 < result.c1) ? colors.a[i].c1 : result.c1;
			result.c2 = (colors.a[i].c2 > result.c2) ? colors.a[i].c2 : result.c2;
		}
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
jne 0xc401
movq 0x342b(%rip), %rax      # 0xf818
movq %rax, -0x10(%rbp)
movq 0x3428(%rip), %rax      # 0xf820
movq %rax, -0x8(%rbp)
jmp 0xc529
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rax), %rsi
movq (%rax), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0xb770
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jae 0xc527
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movl $0x1, %r8d
callq 0xbcb0
cmpl $0x0, %eax
je 0xc514
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0xc4ba
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc4c2
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jbe 0xc504
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xc50c
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc516
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc43b
jmp 0xc529
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc708
jmp 0xc7be
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jae 0xc79b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0xc(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jae 0xc772
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x1040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc725
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc70f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14f0
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x10c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1a60
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl (%rcx)
movl %eax, %eax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0xc843
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jb 0xc848
jmp 0xc94f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xc94d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0xc, -0x30(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x3c(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0xc8b1
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xc8b6
jmp 0xc93c
jmp 0xc8b8
movq -0x50(%rbp), %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
jne 0xc911
movq -0x50(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc8e1
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x58(%rbp)
jmp 0xc8ec
movl $0x2, %eax
movq %rax, -0x58(%rbp)
jmp 0xc8ec
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rdi
imulq $0xc, 0x8(%rax), %rsi
callq 0x1170
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x50(%rbp), %rdx
movq 0x10(%rdx), %rax
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq -0x3c(%rbp), %rcx
movq %rcx, (%rax)
movl -0x34(%rbp), %ecx
movl %ecx, 0x8(%rax)
jmp 0xc93c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc873
jmp 0xc94f
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1e99(%rip), %rsi      # 0xf030
callq 0x1190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd1b1
movq $0x0, -0x8(%rbp)
jmp 0xd1df
movl $0x1, %edi
movl $0x20, %esi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd1f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%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/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd26c
movl $0x0, -0x4(%rbp)
jmp 0xd2aa
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0xd2c0
movq -0x10(%rbp), %rdi
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/marker.c
// Function: marker_read
int marker_read(marker_file_t *pf, marker_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 = marker_parse(pf->buf.l, pf->buf.s, r);
	if (ret < 0) goto file_read_more;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movl $0x2, %esi
leaq -0x20(%rbp), %rcx
callq 0xd380
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xd33e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd36a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd3c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xd364
jmp 0xd310
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rikuu[P]kermit/marker.c
// Function: marker_parse
static int marker_parse(int l, char *s, marker_rec_t *pr)
{
	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->n = q;
		else if (t == 1) pr->p = strtol(q, &r, 10);
		else if (t == 2) pr->bin = strtol(q, &r, 10);
		++t, q = i < l? &s[i+1] : 0;
	}
	if (t < 2) return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0xd4c1
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xd413
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0xd413
jmp 0xd4b3
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x30(%rbp)
jne 0xd432
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xd47c
cmpl $0x1, -0x30(%rbp)
jne 0xd455
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x1120
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0xd47a
cmpl $0x2, -0x30(%rbp)
jne 0xd478
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x1120
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0xc(%rax)
jmp 0xd47a
jmp 0xd47c
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xd4a3
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0xd4ab
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xd4ab
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd3e9
cmpl $0x2, -0x30(%rbp)
jge 0xd4d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd4d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x3130
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3389
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
testb $0x1, -0x9(%rbp)
je 0x3364
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3fe0
testb $0x1, -0xa(%rbp)
je 0x3376
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x4420
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3334
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3100
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movb -0xd(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x11(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x345a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movb 0x10(%rax), %cl
movq -0x8(%rbp), %rax
movb 0x11(%rax), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0x3310
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3403
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4030
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x8(%rcx)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x3519
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4000
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3522
jmp 0x352f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x34f7
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x35b0
movq 0x16a89(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0x10a8b(%rip), %rsi     # 0x14004
movb $0x0, %al
callq 0x3120
movq -0x10(%rbp), %rdi
movq 0x16a6d(%rip), %rax     # 0x19ff8
movq (%rax), %rsi
callq 0x4080
movq 0x16a5e(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0x11b87(%rip), %rsi     # 0x1512b
movb $0x0, %al
callq 0x3120
callq 0x3040
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x3, -0x18(%rbp)
movl $0x4, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
shll $0x2, %eax
movq -0x8(%rbp), %rcx
imull $0x3, 0x8(%rcx), %ecx
cmpl %ecx, %eax
jle 0x360c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
shll %esi
callq 0x36c0
movq -0x10(%rbp), %rdi
callq 0x4030
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x8(%rcx)
movl %edx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x31(%rbp)
je 0x365d
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4000
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x3666
jmp 0x3673
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x363b
cmpq $0x0, -0x30(%rbp)
jne 0x36ad
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
callq 0x32c0
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %edx
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3100
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x379a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3761
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4030
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
callq 0x32c0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x370b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3310
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x36e8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x35c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x382d
movq -0x8(%rbp), %rax
testb $0x1, 0x11(%rax)
je 0x3823
movq -0x20(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x4420
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)