LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgt_read_rec
int bgt_read_rec(bgt_t *bgt, bgt_rec_t *r)
{
	int row;
	const uint8_t **a;
	r->b0 = 0, r->a[0] = r->a[1] = 0;
	if (bgt->n_out == 0) return -1;
	if ((row = bgt_read_core(bgt)) < 0) return row;
	r->b0 = bgt->b0;
	pbf_seek(bgt->pb, row);
	a = pbf_read(bgt->pb);
	r->a[0] = (uint8_t*)a[0], r->a[1] = (uint8_t*)a[1];
	return row;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
cmpl $0x0, 0x34(%rdi)
je 0x16fb9
movq %rsi, %rbx
movq %rdi, %r14
callq 0x16c39
movl %eax, %ebp
testl %eax, %eax
js 0x16fbe
movq 0x18(%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rdi
movl %ebp, %esi
callq 0x158c7
movq 0x8(%r14), %rdi
callq 0x1577a
movq (%rax), %rcx
movq %rcx, 0x8(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0x16fbe
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgt_read
int bgt_read(bgt_t *bgt, bcf1_t *b)
{
	int ret;
	bgt_rec_t r;
	if (bgt->h_out == 0) bgt_prepare(bgt);
	if ((ret = bgt_read_rec(bgt, &r)) < 0) return ret;
	bcfcpy(b, r.b0);
	bgt_gen_gt(bgt->h_out, b, bgt->n_out, r.a, 0);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x58(%rdi)
jne 0x16fe4
movq %r14, %rdi
callq 0x161e0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x16f64
movl %eax, %ebp
testl %eax, %eax
js 0x1701c
leaq 0x8(%rsp), %r15
movq -0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x10f34
movq 0x58(%r14), %rdi
movl 0x34(%r14), %edx
movq %rbx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x1667b
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_reader_init
bgtm_t *bgtm_reader_init(int n_files, bgt_file_t *const* bf)
{
	bgtm_t *bm;
	int i;
	bm = (bgtm_t*)calloc(1, sizeof(bgtm_t));
	bm->n_bgt = n_files;
	bm->bgt = (bgt_t**)calloc(bm->n_bgt, sizeof(void*));
	for (i = 0; i < bm->n_bgt; ++i)
		bm->bgt[i] = bgt_reader_init(bf[i]);
	bm->r = (bgt_rec_t*)calloc(bm->n_bgt, sizeof(bgt_rec_t));
	return bm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebp
movl $0x1, %edi
movl $0xb8, %esi
callq 0x2220
movq %rax, %rbx
movl %ebp, (%rax)
movslq %ebp, %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x2220
movq %rax, 0x38(%rbx)
testl %r15d, %r15d
jle 0x17083
movq %rax, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq (%r14,%rbp,8), %rdi
callq 0x15dd4
movq %rax, (%r12,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x1706e
movl $0x18, %esi
movq %r15, %rdi
callq 0x2220
movq %rax, 0x40(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_reader_destroy
void bgtm_reader_destroy(bgtm_t *bm)
{
	int i;
	free(bm->hap);
	free(bm->alcnt);
	if (bm->site_flt) ke_destroy(bm->site_flt);
	free(bm->mgs);
	free(bm->group);
	free(bm->sample_idx);
	if (bm->h_out) bcf_hdr_destroy(bm->h_out);
	free(bm->a[0]); free(bm->a[1]);
	for (i = 0; i < bm->n_aal; ++i) free(bm->aal[i].chr.s);
	free(bm->aal);
	for (i = 0; i < bm->n_fields; ++i)
		ke_destroy(bm->fields[i]);
	free(bm->fields);
	free(bm->tbl_line.s);
	for (i = 0; i < bm->n_bgt; ++i)
		bgt_reader_destroy(bm->bgt[i]);
	if (bm->h_al) {
		khint_t k;
		khash_t(str) *h = (khash_t(str)*)bm->h_al;
		for (k = 0; k < kh_end(h); ++k)
			if (kh_exist(h, k)) free((char*)kh_key(h, k));
		kh_destroy(str, h);
	}
	free(bm->r); free(bm->bgt); free(bm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb0(%rdi), %rdi
callq 0x2050
movq 0xa8(%rbx), %rdi
callq 0x2050
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x170d7
callq 0x1ced4
movq 0x28(%rbx), %rdi
callq 0x2050
movq 0x20(%rbx), %rdi
callq 0x2050
movq 0x18(%rbx), %rdi
callq 0x2050
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x17100
callq 0xb84a
movq 0x58(%rbx), %rdi
callq 0x2050
movq 0x60(%rbx), %rdi
callq 0x2050
cmpl $0x0, 0x90(%rbx)
jle 0x17147
movl $0x10, %r14d
xorl %r15d, %r15d
movq 0x98(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2050
incq %r15
movslq 0x90(%rbx), %rax
addq $0x30, %r14
cmpq %rax, %r15
jl 0x17124
movq 0x98(%rbx), %rdi
callq 0x2050
cmpl $0x0, 0x68(%rbx)
jle 0x17175
xorl %r14d, %r14d
movq 0x70(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1ced4
incq %r14
movslq 0x68(%rbx), %rax
cmpq %rax, %r14
jl 0x1715c
movq 0x70(%rbx), %rdi
callq 0x2050
movq 0x88(%rbx), %rdi
callq 0x2050
cmpl $0x0, (%rbx)
jle 0x171aa
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x15e9b
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x17192
movq 0xa0(%rbx), %r14
testq %r14, %r14
je 0x1721a
cmpl $0x0, (%r14)
je 0x171f7
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movl %r12d, %ecx
shrl $0x4, %ecx
movl (%rax,%rcx,4), %eax
movl %r15d, %ecx
andb $0x1e, %cl
shrl %cl, %eax
testb $0x3, %al
jne 0x171e8
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x2050
incq %r12
movl (%r14), %eax
addl $0x2, %r15d
cmpq %rax, %r12
jb 0x171c2
movq 0x18(%r14), %rdi
callq 0x2050
movq 0x10(%r14), %rdi
callq 0x2050
movq 0x20(%r14), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
movq 0x40(%rbx), %rdi
callq 0x2050
movq 0x38(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_add_group
int bgtm_add_group(bgtm_t *bm, const char *expr)
{
	int i, ret = 0, size = 0;
	for (i = 0; i < bm->n_bgt; ++i)
		if ((ret = bgt_add_group(bm->bgt[i], expr)) < 0) break;
		else size += ret;
	if (i == bm->n_bgt) ++bm->n_groups; // TODO: revert bm->bgt[i]->n_groups
	return i == bm->n_bgt? size : ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x17279
movq %rsi, %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x160a5
testl %eax, %eax
js 0x17280
addl %eax, %ebp
incq %r15
movslq (%rbx), %rcx
cmpq %rcx, %r15
jl 0x17256
jmp 0x17280
xorl %r15d, %r15d
xorl %ebp, %ebp
xorl %eax, %eax
cmpl (%rbx), %r15d
jne 0x1728a
incl 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_set_region
int bgtm_set_region(bgtm_t *bm, const char *reg)
{
	int i, ret = 0;
	for (i = 0; i < bm->n_bgt; ++i)
		if ((ret = bgt_set_region(bm->bgt[i], reg)) < 0)
			break;
	return ret;
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x172cb
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x16171
testl %eax, %eax
js 0x172ce
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x172a8
xorl %eax, %eax
jmp 0x172d3
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_set_start
int bgtm_set_start(bgtm_t *bm, int64_t n)
{
	int i;
	for (i = 0; i < bm->n_bgt; ++i)
		bgt_set_start(bm->bgt[i], n);
	return 0;
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x17317
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rax
movq (%rax), %rcx
movq 0x10(%rax), %rdi
movq 0x18(%rcx), %rsi
movq %rbx, %rdx
callq 0x1141d
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x172ec
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_set_flt_site
int bgtm_set_flt_site(bgtm_t *bm, const char *expr)
{
	int err;
	if (bm->site_flt) ke_destroy(bm->site_flt);
	bm->site_flt = ke_parse(expr, &err);
	if (err != 0) {
		if (bm->site_flt) ke_destroy(bm->site_flt);
		bm->site_flt = 0;
		return err;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x1735e
callq 0x1ced4
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b574
movq %rax, 0x48(%rbx)
cmpl $0x0, (%r15)
je 0x17393
testq %rax, %rax
je 0x17385
movq %rax, %rdi
callq 0x1ced4
movq $0x0, 0x48(%rbx)
movl 0xc(%rsp), %eax
jmp 0x17395
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_set_mgs
int bgtm_set_mgs(bgtm_t *bm, int mgs_def)
{
	int i;
	for (i = 0; i < bm->n_bgt; ++i) bm->bgt[i]->mgs_def = mgs_def;
	bm->mgs_def = mgs_def;
	return 0;
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x173bd
movq 0x38(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %r8
movl %esi, 0x3c(%r8)
incq %rdx
cmpq %rdx, %rax
jne 0x173ad
movl %esi, 0x30(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_test_mgs
int bgtm_test_mgs(const bgtm_t *bm)
{
	int i, cnt[BGT_MAX_GROUPS];
	memset(cnt, 0, BGT_MAX_GROUPS * sizeof(int));
	for (i = 0; i < bm->n_out; ++i)
		++cnt[bm->group[i]-1];
	for (i = 0; i < bm->n_out; ++i)
		if (bm->mgs[i] > cnt[bm->group[i]-1])
			return 0;
	return 1;
}

// Assembly:
pushq %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rsp)
movaps %xmm0, -0x20(%rsp)
movaps %xmm0, -0x30(%rsp)
movaps %xmm0, -0x40(%rsp)
movaps %xmm0, -0x50(%rsp)
movaps %xmm0, -0x60(%rsp)
movaps %xmm0, -0x70(%rsp)
movaps %xmm0, -0x80(%rsp)
movslq 0x4(%rdi), %rcx
testq %rcx, %rcx
jle 0x1922f
movq 0x20(%rdi), %rax
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
decl %esi
incl -0x80(%rsp,%rsi,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x1921e
movl $0x1, %eax
testl %ecx, %ecx
jle 0x19260
movq 0x20(%rdi), %rdx
movq 0x28(%rdi), %rsi
xorl %edi, %edi
movl (%rsi,%rdi,4), %r8d
movl (%rdx,%rdi,4), %r9d
decl %r9d
cmpl -0x80(%rsp,%r9,4), %r8d
jg 0x1925e
incq %rdi
cmpq %rdi, %rcx
jne 0x19242
jmp 0x19260
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_assign_expr
void bgtm_assign_expr(kexpr_t *e, const bgt_info_t *ss)
{
	int i;
	char key[5];
	ke_set_int(e, "AN", ss->an);
	ke_set_int(e, "AC", ss->ac[0]);
	for (i = 0; i < ss->n_groups; ++i) {
		ke_set_int(e, gen_group_key(key, 'N', i), ss->gan[i]);
		ke_set_int(e, gen_group_key(key, 'C', i), ss->gac[i][0]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %rdx
leaq 0x69e0(%rip), %rsi      # 0x1fc5e
callq 0x1cf2e
movslq (%rbx), %rdx
leaq 0x69d4(%rip), %rsi      # 0x1fc61
movq %r14, %rdi
callq 0x1cf2e
cmpl $0x0, 0xc(%rbx)
jle 0x19390
movl $0x1, %ebp
xorl %r12d, %r12d
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %ebp, %eax
imulq %rdx, %rax
shrq $0x23, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
movb $0x30, %cl
subb %al, %cl
movzbl %cl, %r13d
incq %r13
movw $0x4e41, 0x3(%rsp)      # imm = 0x4E41
cmpq $0x8, %r12
ja 0x192e9
movl $0xcccccccd, %r15d      # imm = 0xCCCCCCCD
leal 0x31(%r12), %eax
movb %al, 0x5(%rsp)
leaq 0x6(%rsp), %rax
jmp 0x1930f
leal 0x1(%r12), %eax
movl $0xcccccccd, %r15d      # imm = 0xCCCCCCCD
imulq %rdx, %rax
shrq $0x23, %rax
addb $0x30, %al
movb %al, 0x5(%rsp)
leal (%r12,%r13), %eax
movb %al, 0x6(%rsp)
leaq 0x7(%rsp), %rax
movb $0x0, (%rax)
movslq 0x10(%rbx,%r12,4), %rdx
movq %r14, %rdi
leaq 0x3(%rsp), %rsi
callq 0x1cf2e
movw $0x4341, 0x3(%rsp)      # imm = 0x4341
cmpq $0x8, %r12
ja 0x19341
leal 0x31(%r12), %eax
movb %al, 0x5(%rsp)
leaq 0x6(%rsp), %rax
jmp 0x19361
leal 0x1(%r12), %eax
imulq %r15, %rax
shrq $0x23, %rax
addb $0x30, %al
movb %al, 0x5(%rsp)
addl %r12d, %r13d
movb %r13b, 0x6(%rsp)
leaq 0x7(%rsp), %rax
movb $0x0, (%rax)
movslq 0x90(%rbx,%r12,8), %rdx
movq %r14, %rdi
leaq 0x3(%rsp), %rsi
callq 0x1cf2e
incq %r12
movslq 0xc(%rbx), %rax
incl %ebp
cmpq %rax, %r12
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
jl 0x192ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_pass_site_flt
int bgtm_pass_site_flt(const bgt_info_t *ss, kexpr_t *flt)
{
	int is_true, err;
	if (flt == 0) return 1;
	bgtm_assign_expr(flt, ss);
	is_true = !!ke_eval_int(flt, &err);
	return err? 0 : is_true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0x193da
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x19262
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ce6c
testq %rax, %rax
setne %al
cmpl $0x0, (%r14)
sete %cl
andb %al, %cl
movzbl %cl, %eax
jmp 0x193df
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_fill_info
void bgtm_fill_info(const bcf_hdr_t *h, const bgt_info_t *ss, bcf1_t *b)
{
	bcf_append_info_ints(h, b, "AN", 1, &ss->an);
	bcf_append_info_ints(h, b, "AC", b->n_allele - 1, ss->ac);
	if (ss->n_groups > 1) {
		int i;
		char key[5];
		for (i = 0; i < ss->n_groups; ++i) {
			bcf_append_info_ints(h, b, gen_group_key(key, 'N', i), 1, &ss->gan[i]);
			bcf_append_info_ints(h, b, gen_group_key(key, 'C', i), b->n_allele - 1, ss->gac[i]);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsi), %r8
leaq 0x6855(%rip), %rdx      # 0x1fc5e
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x113c8
movzwl 0x12(%rbx), %ecx
decl %ecx
leaq 0x683e(%rip), %rdx      # 0x1fc61
movq %r14, 0x18(%rsp)
movq %r14, %rdi
movq %rbx, 0x10(%rsp)
movq %rbx, %rsi
movq %r15, %r8
callq 0x113c8
cmpl $0x2, 0xc(%r15)
jl 0x1956b
cmpl $0x0, 0xc(%r15)
jle 0x1956b
leaq 0x10(%r15), %r12
leaq 0x90(%r15), %r13
movl $0x1, %ebp
xorl %r14d, %r14d
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movq %r15, 0x20(%rsp)
movl %ebp, %eax
imulq %rdx, %rax
shrq $0x23, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
movb $0x30, %cl
subb %al, %cl
movzbl %cl, %r15d
incq %r15
movw $0x4e41, 0xb(%rsp)      # imm = 0x4E41
cmpq $0x8, %r14
ja 0x194a9
movl $0xcccccccd, %ebx       # imm = 0xCCCCCCCD
leal 0x31(%r14), %eax
movb %al, 0xd(%rsp)
leaq 0xe(%rsp), %rax
jmp 0x194cd
leal 0x1(%r14), %eax
movl $0xcccccccd, %ebx       # imm = 0xCCCCCCCD
imulq %rdx, %rax
shrq $0x23, %rax
addb $0x30, %al
movb %al, 0xd(%rsp)
leal (%r15,%r14), %eax
movb %al, 0xe(%rsp)
leaq 0xf(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0xb(%rsp), %rdx
movl $0x1, %ecx
movq %r12, %r8
callq 0x113c8
movw $0x4341, 0xb(%rsp)      # imm = 0x4341
cmpq $0x8, %r14
ja 0x19508
leal 0x31(%r14), %eax
movb %al, 0xd(%rsp)
leaq 0xe(%rsp), %rax
jmp 0x19527
leal 0x1(%r14), %eax
imulq %rbx, %rax
shrq $0x23, %rax
addb $0x30, %al
movb %al, 0xd(%rsp)
addl %r14d, %r15d
movb %r15b, 0xe(%rsp)
leaq 0xf(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rsi
movzwl 0x12(%rsi), %ecx
decl %ecx
movq 0x18(%rsp), %rdi
leaq 0xb(%rsp), %rdx
movq %r13, %r8
callq 0x113c8
incq %r14
movq 0x20(%rsp), %r15
movslq 0xc(%r15), %rax
addq $0x8, %r13
addq $0x4, %r12
incl %ebp
cmpq %rax, %r14
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
jl 0x1946e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_cal_info
void bgtm_cal_info(const bgtm_t *bm, bgt_info_t *ss)
{
	int32_t cnt[4], i;
	memset(cnt, 0, 4 * 4);
	ss->n_groups = bm->n_groups;
	if (bm->n_groups > 1) {
		int32_t j, gcnt[BGT_MAX_GROUPS][4];
		memset(gcnt, 0, 4 * BGT_MAX_GROUPS * 4);
		for (i = 0; i < bm->n_out<<1; ++i)
			++gcnt[bm->group[i>>1]-1][bm->a[1][i]<<1 | bm->a[0][i]];
		for (i = 0; i < bm->n_groups; ++i) {
			ss->gan[i] = gcnt[i][0] + gcnt[i][1] + gcnt[i][3];
			ss->gac[i][0] = gcnt[i][1];
			ss->gac[i][1] = gcnt[i][3];
			for (j = 0; j < 4; ++j) cnt[j] += gcnt[i][j];
		}
	} else {
		for (i = 0; i < bm->n_out<<1; ++i)
			++cnt[bm->a[1][i]<<1 | bm->a[0][i]];
	}
	ss->an = cnt[0] + cnt[1] + cnt[3];
	ss->ac[0] = cnt[1], ss->ac[1] = cnt[3];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl 0x8(%rdi), %eax
movl %eax, 0xc(%rsi)
cmpl $0x1, %eax
jle 0x19663
leaq 0x10(%rsp), %r15
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
xorl %esi, %esi
callq 0x21e0
movl 0x4(%r14), %esi
addl %esi, %esi
testl %esi, %esi
jle 0x19609
movq 0x20(%r14), %rax
movq 0x58(%r14), %rcx
movq 0x60(%r14), %rdx
movl %esi, %esi
xorl %edi, %edi
movl %edi, %r8d
shrl %r8d
movl (%rax,%r8,4), %r8d
decl %r8d
movzbl (%rdx,%rdi), %r9d
movzbl (%rcx,%rdi), %r10d
shll $0x2, %r10d
shll $0x3, %r9d
orl %r10d, %r9d
shlq $0x4, %r8
addq %rsp, %r8
addq $0x10, %r8
incl (%r9,%r8)
incq %rdi
cmpq %rdi, %rsi
jne 0x195d0
cmpl $0x0, 0x8(%r14)
jle 0x19697
xorl %eax, %eax
movq %rax, %rcx
shlq $0x4, %rcx
movl 0x14(%rsp,%rcx), %edx
movl 0x1c(%rsp,%rcx), %esi
movl 0x10(%rsp,%rcx), %ecx
addl %edx, %ecx
addl %esi, %ecx
movl %ecx, 0x10(%rbx,%rax,4)
movl %edx, 0x90(%rbx,%rax,8)
movl %esi, 0x94(%rbx,%rax,8)
xorl %ecx, %ecx
movl (%r15,%rcx,4), %edx
addl %edx, (%rsp,%rcx,4)
incq %rcx
cmpq $0x4, %rcx
jne 0x19641
incq %rax
movslq 0x8(%r14), %rcx
addq $0x10, %r15
cmpq %rcx, %rax
jl 0x19616
jmp 0x19697
movl 0x4(%r14), %edx
addl %edx, %edx
testl %edx, %edx
jle 0x19697
movq 0x58(%r14), %rax
movq 0x60(%r14), %rcx
movl %edx, %edx
xorl %esi, %esi
movzbl (%rcx,%rsi), %edi
movzbl (%rax,%rsi), %r8d
shll $0x2, %r8d
shll $0x3, %edi
orl %r8d, %edi
incl (%rsp,%rdi)
incq %rsi
cmpq %rsi, %rdx
jne 0x19679
movl 0x4(%rsp), %eax
movl 0xc(%rsp), %ecx
movl (%rsp), %edx
addl %eax, %edx
addl %ecx, %edx
movl %edx, 0x8(%rbx)
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_assign_by_bcf
void bgtm_assign_by_bcf(kexpr_t *e, const bcf_hdr_t *h, const bcf1_t *b)
{
	int l_ref, l_alt, max_l;
	char *ref, *alt, *tmp;
	ke_set_str(e, "CHROM", h->id[BCF_DT_CTG][b->rid].key);
	ke_set_int(e, "POS", b->pos + 1);
	ke_set_int(e, "END", b->pos + b->rlen);
	bcf_get_ref_alt1(b, &l_ref, &ref, &l_alt, &alt);
	max_l = l_ref > l_alt? l_ref : l_alt;
	tmp = (char*)alloca(max_l + 1);
	strncpy(tmp, ref, l_ref); tmp[l_ref] = 0;
	ke_set_str(e, "REF", tmp);
	strncpy(tmp, alt, l_alt); tmp[l_alt] = 0;
	ke_set_str(e, "ALT", tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movslq (%rdx), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdx
leaq 0x657c(%rip), %rsi      # 0x1fc64
callq 0x1d0a0
movslq 0x4(%r12), %rdx
incq %rdx
leaq 0x656e(%rip), %rsi      # 0x1fc6a
movq %rbx, %rdi
callq 0x1cf2e
movslq 0x4(%r12), %rax
movslq 0x8(%r12), %rdx
addq %rax, %rdx
leaq 0x5d03(%rip), %rsi      # 0x1f41b
movq %rbx, %rdi
callq 0x1cf2e
leaq -0x38(%rbp), %r13
leaq -0x40(%rbp), %r15
leaq -0x34(%rbp), %r14
leaq -0x30(%rbp), %r8
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x110dd
movslq (%r13), %r13
movl (%r14), %eax
cmpl %eax, %r13d
cmovgl %r13d, %eax
cltq
addq $0x10, %rax
andq $-0x10, %rax
movq %rsp, %r12
subq %rax, %r12
movq %r12, %rsp
movq (%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x2080
xorl %r15d, %r15d
movb %r15b, (%r13,%r12)
leaq 0x64ef(%rip), %rsi      # 0x1fc6e
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1d0a0
leaq -0x30(%rbp), %rax
movq (%rax), %rsi
movslq (%r14), %r14
movq %r12, %rdi
movq %r14, %rdx
callq 0x2080
movb %r15b, (%r14,%r12)
leaq 0x64c8(%rip), %rsi      # 0x1fc72
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1d0a0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_read
int bgtm_read(bgtm_t *bm, bcf1_t *b)
{
	int ret;
	if (bm->h_out == 0) bgtm_prepare(bm);
	while ((ret = bgtm_read_core(bm, b)) > 0);
	if ((bm->flag & BGT_F_NO_GT) == 0)
		bgt_gen_gt(bm->h_out, b, bm->n_out, (const uint8_t**)bm->a, bm->mgs);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jne 0x1a395
movq %rbx, %rdi
callq 0x183a4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19b5e
testl %eax, %eax
jg 0x1a395
movl %eax, %ebp
testb $0x2, 0xc(%rbx)
jne 0x1a3c6
movq 0x50(%rbx), %rdi
movl 0x4(%rbx), %edx
movq 0x28(%rbx), %r8
addq $0x58, %rbx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x1667b
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/bgt.c
// Function: bgtm_alcnt_print
char *bgtm_alcnt_print(const bgtm_t *bm)
{
	int i;
	kstring_t s = {0,0,0};
	for (i = 0; i < bm->n_out; ++i) {
		if (bm->alcnt[i] == bm->n_aal) {
			bgt_t *bgt = bm->bgt[bm->sample_idx[i]>>32];
			if (bm->mgs[i] > 1) continue;
			ksprintf(&s, "SP\t%s\t%d\n", bgt->f->f->rows[(uint32_t)bm->sample_idx[i]].name, (int)(bm->sample_idx[i]>>32) + 1);
		}
	}
	return s.s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x4(%rdi)
jle 0x1af8e
movq %rdi, %rbx
leaq 0x4dba(%rip), %r14      # 0x1fce0
movq %rsp, %r15
xorl %r12d, %r12d
movq 0xa8(%rbx), %rax
movl (%rax,%r12,4), %eax
cmpl 0x90(%rbx), %eax
jne 0x1af82
movq 0x28(%rbx), %rax
cmpl $0x1, (%rax,%r12,4)
jg 0x1af82
movq 0x18(%rbx), %rax
movq 0x38(%rbx), %rdx
movq (%rax,%r12,8), %rcx
movl %ecx, %eax
shrq $0x20, %rcx
movq (%rdx,%rcx,8), %rdx
movq (%rdx), %rdx
movq 0x8(%rdx), %rdx
movq 0x28(%rdx), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rdx
incl %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x190a5
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0x1af2c
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/kexpr.c
// Function: ke_destroy
void ke_destroy(kexpr_t *ke)
{
	int i;
	if (ke == 0) return;
	for (i = 0; i < ke->n; ++i) {
		free(ke->e[i].name);
		free(ke->e[i].s);
	}
	free(ke->e); free(ke);
}

// Assembly:
testq %rdi, %rdi
je 0x1cf2d
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x1cf17
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14), %rdi
callq 0x2050
movq 0x8(%rbx), %rax
movq 0x28(%rax,%r14), %rdi
callq 0x2050
incq %r15
movslq (%rbx), %rax
addq $0x30, %r14
cmpq %rax, %r15
jl 0x1ceec
movq 0x8(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/kexpr.c
// Function: ke_set_int
int ke_set_int(kexpr_t *ke, const char *var, int64_t y)
{
	int i, n = 0;
	double yy = (double)y;
	for (i = 0; i < ke->n; ++i) {
		ke1_t *e = &ke->e[i];
		if (e->ttype == KET_VAL && e->name && strcmp(e->name, var) == 0)
			e->i = y, e->r = yy, e->vtype = KEV_INT, e->assigned = 1, ++n;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, (%rdi)
jle 0x1cfcb
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, 0x10(%rsp)
cvtsi2sd %rdx, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r12d, %r12d
xorl %r13d, %r13d
movl $0x0, 0x4(%rsp)
movq 0x8(%r15), %rbx
movq (%rbx,%r12), %rbp
cmpw $0x1, %bp
jne 0x1cfba
movq 0x8(%rbx,%r12), %rdi
testq %rdi, %rdi
je 0x1cfba
movq %r14, %rsi
callq 0x2230
testl %eax, %eax
jne 0x1cfba
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rbx,%r12)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rbx,%r12)
andq $-0x7ffffff, %rbp       # imm = 0xF8000001
orq $0x4020000, %rbp        # imm = 0x4020000
movq %rbp, (%rbx,%r12)
incl 0x4(%rsp)
incq %r13
movslq (%r15), %rax
addq $0x30, %r12
cmpq %rax, %r13
jl 0x1cf69
jmp 0x1cfd3
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/kexpr.c
// Function: ke_set_real
int ke_set_real(kexpr_t *ke, const char *var, double x)
{
	int i, n = 0;
	int64_t xx = (int64_t)(x + .5);
	for (i = 0; i < ke->n; ++i) {
		ke1_t *e = &ke->e[i];
		if (e->ttype == KET_VAL && e->name && strcmp(e->name, var) == 0)
			e->r = x, e->i = xx, e->vtype = KEV_REAL, e->assigned = 1, ++n;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
cmpl $0x0, (%rdi)
jle 0x1d08d
movq %rdi, %r14
movapd %xmm0, %xmm1
movsd 0x1e57(%rip), %xmm0     # 0x1ee68
movsd %xmm1, 0x8(%rsp)
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, (%rsp)
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%r14), %r15
movq (%r15,%r12), %rbx
cmpw $0x1, %bx
jne 0x1d07c
movq 0x8(%r15,%r12), %rdi
testq %rdi, %rdi
je 0x1d07c
movq 0x10(%rsp), %rsi
callq 0x2230
testl %eax, %eax
jne 0x1d07c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%r15,%r12)
movq (%rsp), %rax
movq %rax, 0x20(%r15,%r12)
andq $-0x7ffffff, %rbx       # imm = 0xF8000001
orq $0x4010000, %rbx        # imm = 0x4010000
movq %rbx, (%r15,%r12)
incl %ebp
incq %r13
movslq (%r14), %rax
addq $0x30, %r12
cmpq %rax, %r13
jl 0x1d02c
jmp 0x1d08f
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/kexpr.c
// Function: ke_set_str
int ke_set_str(kexpr_t *ke, const char *var, const char *x)
{
	int i, n = 0;
	for (i = 0; i < ke->n; ++i) {
		ke1_t *e = &ke->e[i];
		if (e->ttype == KET_VAL && e->name && strcmp(e->name, var) == 0) {
			if (e->vtype == KEV_STR) free(e->s);
			e->s = strdup(x);
			e->i = 0, e->r = 0., e->assigned = 1;
			e->vtype = KEV_STR;
			++n;
		}
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
cmpl $0x0, (%rdi)
jle 0x1d151
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movl $0x0, 0xc(%rsp)
movq 0x8(%r15), %rbx
movq (%rbx,%r12), %rbp
cmpw $0x1, %bp
jne 0x1d140
movq 0x8(%rbx,%r12), %rdi
testq %rdi, %rdi
je 0x1d140
movq %r14, %rsi
callq 0x2230
testl %eax, %eax
jne 0x1d140
andl $0x3ff0000, %ebp        # imm = 0x3FF0000
cmpl $0x30000, %ebp          # imm = 0x30000
jne 0x1d10c
movq 0x28(%rbx,%r12), %rdi
callq 0x2050
movq 0x10(%rsp), %rdi
callq 0x2420
movq %rax, 0x28(%rbx,%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx,%r12)
movq (%rbx,%r12), %rax
movq $-0x7ff0001, %rcx       # imm = 0xF800FFFF
andq %rcx, %rax
orq $0x4030000, %rax        # imm = 0x4030000
movq %rax, (%rbx,%r12)
incl 0xc(%rsp)
incq %r13
movslq (%r15), %rax
addq $0x30, %r12
cmpq %rax, %r13
jl 0x1d0d0
jmp 0x1d159
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/kexpr.c
// Function: ke_set_real_func1
int ke_set_real_func1(kexpr_t *ke, const char *name, double (*func)(double))
{
	int i, n = 0;
	for (i = 0; i < ke->n; ++i) {
		ke1_t *e = &ke->e[i];
		if (e->ttype == KET_FUNC && e->n_args == 1 && strcmp(e->name, name) == 0)
			e->f.real_func1 = func, e->user_func = KEF_REAL, ++n;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
cmpl $0x0, (%rdi)
jle 0x1d218
movq %rdi, %r15
xorl %r12d, %r12d
movabsq $-0xffffff0001, %rbx    # imm = 0xFFFFFF000000FFFF
movabsq $0x10000000003, %rdx    # imm = 0x10000000003
xorl %ebp, %ebp
movl $0x0, 0x4(%rsp)
movq 0x8(%r15), %r14
movq (%r14,%r12), %r13
movq %r13, %rax
andq %rbx, %rax
cmpq %rdx, %rax
jne 0x1d207
movq 0x8(%r14,%r12), %rdi
movq 0x10(%rsp), %rsi
callq 0x2230
testl %eax, %eax
jne 0x1d1fd
movq 0x8(%rsp), %rax
movq %rax, 0x10(%r14,%r12)
movabsq $0x1ff07ff0003, %rax    # imm = 0x1FF07FF0003
andq %rax, %r13
orq $0x8000000, %r13        # imm = 0x8000000
movq %r13, (%r14,%r12)
incl 0x4(%rsp)
movabsq $0x10000000003, %rdx    # imm = 0x10000000003
incq %rbp
movslq (%r15), %rax
addq $0x30, %r12
cmpq %rax, %rbp
jl 0x1d1b1
jmp 0x1d220
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/kexpr.c
// Function: ke_set_real_func2
int ke_set_real_func2(kexpr_t *ke, const char *name, double (*func)(double, double))
{
	int i, n = 0;
	for (i = 0; i < ke->n; ++i) {
		ke1_t *e = &ke->e[i];
		if (e->ttype == KET_FUNC && e->n_args == 2 && strcmp(e->name, name) == 0)
			e->f.real_func2 = func, e->user_func = KEF_REAL, ++n;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
cmpl $0x0, (%rdi)
jle 0x1d2df
movq %rdi, %r15
xorl %r12d, %r12d
movabsq $-0xffffff0001, %rbx    # imm = 0xFFFFFF000000FFFF
movabsq $0x20000000003, %rdx    # imm = 0x20000000003
xorl %ebp, %ebp
movl $0x0, 0x4(%rsp)
movq 0x8(%r15), %r14
movq (%r14,%r12), %r13
movq %r13, %rax
andq %rbx, %rax
cmpq %rdx, %rax
jne 0x1d2ce
movq 0x8(%r14,%r12), %rdi
movq 0x10(%rsp), %rsi
callq 0x2230
testl %eax, %eax
jne 0x1d2c4
movq 0x8(%rsp), %rax
movq %rax, 0x10(%r14,%r12)
movabsq $0x2ff07ff0003, %rax    # imm = 0x2FF07FF0003
andq %rax, %r13
orq $0x8000000, %r13        # imm = 0x8000000
movq %r13, (%r14,%r12)
incl 0x4(%rsp)
movabsq $0x20000000003, %rdx    # imm = 0x20000000003
incq %rbp
movslq (%r15), %rax
addq $0x30, %r12
cmpq %rax, %rbp
jl 0x1d278
jmp 0x1d2e7
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/kexpr.c
// Function: ke_set_default_func
int ke_set_default_func(kexpr_t *ke)
{
	int n = 0;
	n += ke_set_real_func1(ke, "exp", exp);
	n += ke_set_real_func1(ke, "log", log);
	n += ke_set_real_func1(ke, "log10", log10);
	n += ke_set_real_func1(ke, "sqrt", sqrt);
	n += ke_set_real_func1(ke, "sin", sin);
	n += ke_set_real_func1(ke, "cos", cos);
	n += ke_set_real_func1(ke, "tan", tan);
	n += ke_set_real_func2(ke, "pow", pow);
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2ba5(%rip), %rsi      # 0x1feb0
movq 0x8cde(%rip), %rdx      # 0x25ff0
callq 0x1d16c
movl %eax, %ebp
leaq 0x2b94(%rip), %rsi      # 0x1feb4
movq 0x8c79(%rip), %rdx      # 0x25fa0
movq %rbx, %rdi
callq 0x1d16c
movl %eax, %r14d
addl %ebp, %r14d
leaq 0x2b7c(%rip), %rsi      # 0x1feb8
movq 0x8c75(%rip), %rdx      # 0x25fb8
movq %rbx, %rdi
callq 0x1d16c
movl %eax, %r15d
leaq 0x2b69(%rip), %rsi      # 0x1febe
movq 0x8c84(%rip), %rdx      # 0x25fe0
movq %rbx, %rdi
callq 0x1d16c
movl %eax, %ebp
addl %r15d, %ebp
addl %r14d, %ebp
leaq 0x2b50(%rip), %rsi      # 0x1fec3
movq 0x8c56(%rip), %rdx      # 0x25fd0
movq %rbx, %rdi
callq 0x1d16c
movl %eax, %r14d
leaq 0x2b3b(%rip), %rsi      # 0x1fec7
movq 0x8c15(%rip), %rdx      # 0x25fa8
movq %rbx, %rdi
callq 0x1d16c
movl %eax, %r15d
addl %r14d, %r15d
leaq 0x2b23(%rip), %rsi      # 0x1fecb
movq 0x8c19(%rip), %rdx      # 0x25fc8
movq %rbx, %rdi
callq 0x1d16c
movl %eax, %r14d
addl %r15d, %r14d
addl %ebp, %r14d
leaq 0x2b08(%rip), %rsi      # 0x1fecf
movq 0x8bc2(%rip), %rdx      # 0x25f90
movq %rbx, %rdi
callq 0x1d233
addl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/kexpr.c
// Function: ke_unset
void ke_unset(kexpr_t *ke)
{
	int i;
	for (i = 0; i < ke->n; ++i) {
		ke1_t *e = &ke->e[i];
		if (e->ttype == KET_VAL && e->name) e->assigned = 0;
	}
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x1d41d
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x8(%rdi), %rdx
movq (%rdx,%rax), %rsi
cmpw $0x1, %si
jne 0x1d40e
cmpq $0x0, 0x8(%rdx,%rax)
je 0x1d40e
andq $-0x400ffff, %rsi       # imm = 0xFBFF0001
movq %rsi, (%rdx,%rax)
incq %rcx
movslq (%rdi), %rdx
addq $0x30, %rax
cmpq %rdx, %rcx
jl 0x1d3ed
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]bgt/kexpr.c
// Function: ke_print
void ke_print(const kexpr_t *ke)
{
	int i;
	if (ke == 0) return;
	for (i = 0; i < ke->n; ++i) {
		const ke1_t *u = &ke->e[i];
		if (i) putchar(' ');
		if (u->ttype == KET_VAL) {
			if (u->name) printf("%s", u->name);
			else if (u->vtype == KEV_REAL) printf("%g", u->r);
			else if (u->vtype == KEV_INT) printf("%lld", (long long)u->i);
			else if (u->vtype == KEV_STR) printf("\"%s\"", u->s);
		} else if (u->ttype == KET_OP) {
			printf("%s", ke_opstr[u->op]);
		} else if (u->ttype == KET_FUNC) {
			printf("%s(%d)", u->name, u->n_args);
		}
	}
	putchar('\n');
}

// Assembly:
testq %rdi, %rdi
je 0x1d52f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x1d517
leaq 0x296f(%rip), %r12      # 0x1fdb4
leaq 0x2a87(%rip), %r15      # 0x1fed3
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %r14
testq %r13, %r13
je 0x1d464
movl $0x20, %edi
callq 0x2060
movq (%r14,%r13), %rdx
cmpw $0x3, %dx
je 0x1d4cf
movzwl %dx, %eax
cmpl $0x2, %eax
je 0x1d4b4
cmpl $0x1, %eax
jne 0x1d4e6
movq 0x8(%r14,%r13), %rsi
testq %rsi, %rsi
jne 0x1d4c3
shrl $0x10, %edx
andl $0x3ff, %edx            # imm = 0x3FF
cmpl $0x3, %edx
je 0x1d509
cmpl $0x2, %edx
je 0x1d4fb
cmpl $0x1, %edx
jne 0x1d4e6
movsd 0x18(%r14,%r13), %xmm0
leaq 0x1c29(%rip), %rdi      # 0x1f0d4
movb $0x1, %al
callq 0x2190
jmp 0x1d4e6
shrq $0x20, %rdx
movsbq %dl, %rax
movslq (%r12,%rax,4), %rsi
addq %r12, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2190
jmp 0x1d4e6
movq 0x8(%r14,%r13), %rsi
sarq $0x28, %rdx
leaq 0x29fc(%rip), %rdi      # 0x1fedb
xorl %eax, %eax
callq 0x2190
incq %rbp
movslq (%rbx), %rax
addq $0x30, %r13
cmpq %rax, %rbp
jl 0x1d451
jmp 0x1d517
movq 0x20(%r14,%r13), %rsi
leaq 0x1bc8(%rip), %rdi      # 0x1f0cf
jmp 0x1d4c6
movq 0x28(%r14,%r13), %rsi
leaq 0x29c1(%rip), %rdi      # 0x1fed6
jmp 0x1d4c6
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::Fase(Graph*, bool)
Fase::Fase(Graph* _g, bool _directed)
{
  directed = _directed;
  graph = _g;
  sampling = false;

  vext = new int*[MAXMOTIF];
  for (int i = 1; i < MAXMOTIF; i++)
    vext[i] = new int[graph->numNodes()];

  vextSz = new int[MAXMOTIF];
  vsub = new int[MAXMOTIF];
  sampProb = new double[MAXMOTIF];

  Label::init(_g, _directed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x46ac
leaq 0x58(%r14), %rax
movl $0x0, 0x58(%r14)
xorl %ecx, %ecx
movq %rcx, 0x60(%r14)
movq %rax, 0x68(%r14)
movq %rax, 0x70(%r14)
movq %rcx, 0x78(%r14)
movb %bpl, (%r14)
movq %r15, 0x8(%r14)
movb $0x0, 0x1(%r14)
movl $0xa0, %edi
callq 0x2030
movq %rax, 0x80(%r14)
movl $0x1, %r12d
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq $-0x1, %rdi
testl %eax, %eax
js 0x28b5
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x2030
movq 0x80(%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq $0x14, %r12
jne 0x2899
movl $0x50, %edi
callq 0x2030
movq %rax, 0x88(%r14)
movl $0x50, %edi
callq 0x2030
movq %rax, 0x90(%r14)
movl $0xa0, %edi
callq 0x2030
movq %rax, 0x98(%r14)
movzbl %bpl, %esi
movq %r15, %rdi
callq 0x449c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2918
movq %rax, %r15
addq $0x50, %r14
movq %r14, %rdi
callq 0x322a
movq %rbx, %rdi
callq 0x46bc
movq %r15, %rdi
callq 0x22c0
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::~Fase()
Fase::~Fase()
{
  for (int i = 1; i < MAXMOTIF; i++)
    delete[] vext[i];
  delete[] vext;
  delete[] vextSz;
  delete[] vsub;
  delete[] sampProb;

  igtrie.destroy();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r14d
movq 0x80(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x295a
callq 0x2220
incq %r14
cmpq $0x14, %r14
jne 0x2945
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x2974
callq 0x2220
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x2985
callq 0x2220
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x2996
callq 0x2220
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x29a7
callq 0x2220
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x46de
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x322a
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x46bc
movq %rax, %rdi
callq 0x3147
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::initSampling(int, double*)
void Fase::initSampling(int sz, double* _sampProb)
{
  int i;
  for (i = 0; i < sz; i++)
    sampProb[i] = _sampProb[i];

  sampling = true;
}

// Assembly:
testl %esi, %esi
jle 0x29f7
movq 0x98(%rdi), %rax
movl %esi, %ecx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x29e5
movb $0x1, 0x1(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::runCensus(int)
void Fase::runCensus(int _K)
{
  K = _K;
  motifCount = 0;
  igtrie.init(K);

  for (int i = 0; i < graph->numNodes(); i++)
    if (!sampling || Random::testProb(sampProb[0]))
    {
      vsub[0] = i;
      int *nei = graph->arrayNeighbours(i);
      int neiNum = graph->numNeighbours(i);

      vextSz[1] = 0;
      for (int j = 0; j < neiNum; j++)
        if (nei[j] > i)
          vext[1][vextSz[1]++] = nei[j];
    
      expandEnumeration(1, 0, 0LL);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
addq $0x18, %rdi
callq 0x473c
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testl %eax, %eax
jle 0x2ad9
xorl %r14d, %r14d
cmpb $0x1, 0x1(%rbx)
jne 0x2a46
movq 0x98(%rbx), %rax
movsd (%rax), %xmm0
callq 0x794c
testb %al, %al
je 0x2ac3
movq 0x90(%rbx), %rax
movl %r14d, (%rax)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0xa8(%rax)
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x68(%rax)
movq 0x88(%rbx), %rcx
movl $0x0, 0x4(%rcx)
testl %eax, %eax
jle 0x2ab2
movq 0x80(%rbx), %rdx
movl %eax, %eax
xorl %esi, %esi
movl (%r15,%rsi,4), %edi
cmpl %r14d, %edi
jle 0x2aaa
movq 0x8(%rdx), %r8
movslq 0x4(%rcx), %r9
leal 0x1(%r9), %r10d
movl %r10d, 0x4(%rcx)
movl %edi, (%r8,%r9,4)
incq %rsi
cmpq %rsi, %rax
jne 0x2a8d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2ae0
incl %r14d
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpl %eax, %r14d
jl 0x2a2c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::getSubgraphFrequency(std::pair<long long, int>, Isomorphism*)
void Fase::getSubgraphFrequency(pair<long long int, int> element, Isomorphism* iso)
{
  Label::fillNautyMatrix(sadjM, K, element.first);

  nauty_s[0] = '\0';
  iso->canonicalStrNauty(sadjM, nauty_s);
  string str = string(nauty_s);
  canonicalTypes[str] += element.second;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movl %edx, 0x4(%rsp)
movq %rsi, %rdx
movq %rdi, %r14
leaq 0xa0(%rdi), %r13
movl 0x10(%rdi), %esi
movq %r13, %rdi
callq 0x457c
leaq 0x231(%r14), %r15
movb $0x0, 0x231(%r14)
leaq 0x38(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq %r13, %rdi
callq 0x20b0
leaq (%r14,%rax), %rdx
addq $0xa0, %rdx
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3332
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x4c58
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2e49
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x20b0
leaq (%rax,%r15), %rdx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x3332
addq $0x50, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3152
movl 0x4(%rsp), %ecx
addl %ecx, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2e9a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2edc
movq 0x18(%rsp), %rsi
jmp 0x2ed4
movq %rax, %r14
jmp 0x2edc
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2edc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::subgraphCount[abi:cxx11]()
vector<pair<int, string> > Fase::subgraphCount()
{
  reduceCanonicalTypes();

  vector<pair<int, string> > subgraphVector;
  for (auto element : canonicalTypes)
    subgraphVector.push_back(make_pair(element.second, element.first));

  sort(subgraphVector.begin(), subgraphVector.end());
  reverse(subgraphVector.begin(), subgraphVector.end());

  return subgraphVector;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2ee4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x68(%r14), %r15
addq $0x58, %r14
cmpq %r14, %r15
je 0x3095
leaq 0x18(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq 0x30(%rsp), %rbp
movq %r12, 0x8(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x32a2
movl 0x40(%r15), %eax
movl %eax, 0x28(%rsp)
movl %eax, 0x30(%rsp)
movq %r13, 0x38(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x32a2
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3718
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x306a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3081
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %r15, %rdi
callq 0x20e0
movq %rax, %r15
cmpq %r14, %rax
jne 0x3006
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x30dc
movq %r15, %rax
subq %r14, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x39dd
movq %r14, %rdi
movq %r15, %rsi
callq 0x3aba
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x444f
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30fc
movq %rax, %r14
jmp 0x3137
movq %rax, %r14
jmp 0x3120
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x3120
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3137
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x31ce
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/Label.cpp
// Function: Label::updateLabel(int*, int, int)
long long int Label::updateLabel(int* vsub, int currentVertex, int depth)
{
  long long int label = 0;

  if (directed)
  {
    for (int i = 0; i < depth; i++)
    {
      label |= ((1LL << (2 * i)) * graph->hasEdge(vsub[i], currentVertex));
      label |= ((1LL << (2 * i + 1)) * graph->hasEdge(currentVertex, vsub[i]));
    }
  }
  else
  {
    for (int i = 0; i < depth; i++)
      label |= ((1LL << i) * graph->isConnected(vsub[i], currentVertex));
  }

  return label;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x0, 0xedd5(%rip)      # 0x13298
je 0x4524
testl %edx, %edx
jle 0x455a
movl %edx, %r13d
addq %r13, %r13
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0xedb0(%rip), %rdi      # 0x13290
movl (%r14,%r12,2), %esi
movq (%rdi), %rax
movl %ebx, %edx
callq *0x48(%rax)
movzbl %al, %ebp
movl %r12d, %ecx
shlq %cl, %rbp
movq 0xed94(%rip), %rdi      # 0x13290
movl (%r14,%r12,2), %edx
movq (%rdi), %rax
movl %ebx, %esi
callq *0x48(%rax)
movzbl %al, %eax
leal 0x1(%r12), %ecx
shlq %cl, %rax
orq %rbp, %rax
orq %rax, %r15
addq $0x2, %r12
cmpq %r12, %r13
jne 0x44d9
jmp 0x455d
testl %edx, %edx
jle 0x455a
movl %edx, %r13d
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0xed58(%rip), %rdi      # 0x13290
movl (%r14,%r12,4), %esi
movq (%rdi), %rax
movl %ebx, %edx
callq *0x50(%rax)
movzbl %al, %eax
movl %r12d, %ecx
shlq %cl, %rax
orq %rax, %r15
incq %r12
cmpq %r12, %r13
jne 0x4531
jmp 0x455d
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/Label.cpp
// Function: Label::fillNautyMatrix(char*, int, long long)
void Label::fillNautyMatrix(char* sadjM, int K, long long int mask)
{
  int i, j;
  for (i = 0; i < K * K; i++)
    sadjM[i] = '0';
  sadjM[K * K] = '\0';

  int acc = 0;
  for (i = K - 1; i >= 1; i--)
  {
    int gone = 0;
    for (j = 0; j < i; j++)
    {
      if (directed)
      {
        sadjM[j * K + i] =
          ((mask & (1LL << (2 * j + acc))) > 0) ? '1' : '0';
        sadjM[i * K + j] =
          ((mask & (1LL << ((2 * j + 1) + acc))) > 0) ? '1' : '0';
        gone += 2;
      }
      else
      {
        sadjM[i * K + j] = sadjM[j * K + i] =
          ((mask & (1LL << (j + acc))) > 0) ? '1' : '0';
        gone++;
      }
    }

    acc += gone;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %ebp
imull %esi, %ebp
testl %esi, %esi
je 0x45b1
cmpl $0x1, %ebp
movl %ebp, %edx
adcl $0x0, %edx
movq %r15, %rdi
movl $0x30, %esi
callq 0x20d0
movl %ebp, %eax
movb $0x0, (%r15,%rax)
cmpl $0x2, %r14d
jl 0x469d
movl %r14d, %esi
decl %r14d
leaq -0x1(%rsi), %rdi
imulq %rsi, %rdi
addq %r15, %rdi
movq %rsi, %rax
negq %rax
movq %rax, 0x8(%rsp)
leaq (%r15,%rsi), %r9
decq %r9
xorl %r11d, %r11d
movq %rsi, %r10
leaq -0x1(%r10), %rax
movq %rax, 0x10(%rsp)
movl %r11d, %r12d
movq %r12, %rax
movq %r12, %rdx
movq %r9, %r13
movq %rdi, %rbp
xorl %r8d, %r8d
xorl %r11d, %r11d
cmpb $0x1, 0xec88(%rip)      # 0x13298
jne 0x4647
movl $0x1, %r15d
movl %eax, %ecx
shlq %cl, %r15
testq %rbx, %r15
setg %cl
orb $0x30, %cl
movb %cl, (%r13)
leal 0x1(%rax), %ecx
movl $0x1, %r15d
shlq %cl, %r15
testq %rbx, %r15
setg %cl
orb $0x30, %cl
movl $0x2, %r15d
jmp 0x4665
movl $0x1, %r15d
movl %edx, %ecx
shlq %cl, %r15
testq %rbx, %r15
setg %cl
orb $0x30, %cl
movb %cl, (%r13)
movl $0x1, %r15d
addl %r15d, %r11d
movb %cl, (%rbp)
incq %r8
incq %rbp
addq %rsi, %r13
incq %rdx
addq $0x2, %rax
cmpq %r8, %r14
jne 0x4609
addl %r12d, %r11d
decq %r14
addq 0x8(%rsp), %rdi
decq %r9
cmpq $0x2, %r10
movq 0x10(%rsp), %r10
jg 0x45eb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/IGtrie.cpp
// Function: IGtrie::destroy()
void IGtrie::destroy()
{
  if (!numLabels)
    return;

  int i;
  for (i = 0; i < numLabels; i++)
    delete[] labelPaths[i];

  free(labelPaths);
  free(labelLeaf);
  free(labelCount);
  numLabels = 0;
  maxLabels = 0;
}

// Assembly:
cmpl $0x0, 0x4(%rdi)
je 0x473b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
jle 0x4712
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4706
callq 0x2220
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x46f4
movq 0x8(%rbx), %rdi
callq 0x21e0
movq 0x10(%rbx), %rdi
callq 0x21e0
movq 0x18(%rbx), %rdi
callq 0x21e0
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/IGtrie.cpp
// Function: IGtrie::init(int)
void IGtrie::init(int K)
{
  maxLabels = 10 * K * K;
  numLabels = 1;
  labelPaths = (int**) malloc(sizeof(int*) * maxLabels);
  labelLeaf = (int*) malloc(sizeof(int) * maxLabels);
  labelCount = (int*) malloc(sizeof(int) * maxLabels);

  labelPaths[0] = new int[LB_WORD_SIZE];
  labelLeaf[0] = 1;
  labelCount[0] = 0;
  memset(labelPaths[0], -1, sizeof(int) * LB_WORD_SIZE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
imull %esi, %esi
addl %esi, %esi
leal (%rsi,%rsi,4), %eax
movl %eax, (%rdi)
movl $0x1, %ebp
movl %ebp, 0x4(%rdi)
movslq %eax, %r14
leaq (,%r14,8), %rdi
callq 0x2230
movq %rax, %r15
movq %rax, 0x8(%rbx)
shlq $0x2, %r14
movq %r14, %rdi
callq 0x2230
movq %rax, %r12
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x2230
movq %rax, %r14
movq %rax, 0x18(%rbx)
movl $0x40, %edi
callq 0x2030
movq %rax, (%r15)
movl %ebp, (%r12)
movl $0x0, (%r14)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x30(%rax)
movdqu %xmm0, 0x20(%rax)
movdqu %xmm0, 0x10(%rax)
movdqu %xmm0, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq