LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsi), %r8
leaq 0x6376(%rip), %rdx      # 0x19c2e
pushq $0x1
popq %rcx
movq %rbx, %rsi
callq 0xd67c
movzwl 0x12(%rbx), %ecx
decl %ecx
leaq 0x6361(%rip), %rdx      # 0x19c31
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %r8
callq 0xd67c
movl 0xc(%r14), %eax
cmpl $0x2, %eax
jl 0x139c0
leaq 0x10(%r14), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x90(%r14), %rcx
movq %rcx, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x3(%rsp), %r12
cltq
cmpq %rax, %r13
jge 0x139c0
movw $0x4e41, 0x3(%rsp)      # imm = 0x4E41
cmpq $0x8, %r13
ja 0x13928
leal 0x31(%r13), %eax
xorl %edx, %edx
jmp 0x1393d
leal 0x1(%r13), %eax
xorl %edx, %edx
pushq $0xa
popq %rcx
divl %ecx
addb $0x30, %al
orb $0x30, %dl
movb $0x0, 0x7(%rsp)
movb %al, 0x5(%rsp)
movb %dl, 0x6(%rsp)
movq 0x10(%rsp), %rax
leaq (%rax,%r13,4), %r8
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
pushq $0x1
popq %rcx
callq 0xd67c
movw $0x4341, 0x3(%rsp)      # imm = 0x4341
cmpq $0x8, %r13
ja 0x13978
leal 0x31(%r13), %eax
leaq 0x1(%r13), %rbp
xorl %edx, %edx
jmp 0x1398f
leaq 0x1(%r13), %rbp
movl %ebp, %eax
xorl %edx, %edx
pushq $0xa
popq %rcx
divl %ecx
addb $0x30, %al
orb $0x30, %dl
movb $0x0, 0x7(%rsp)
movb %al, 0x5(%rsp)
movb %dl, 0x6(%rsp)
movzwl 0x12(%rbx), %ecx
decl %ecx
movq 0x8(%rsp), %rax
leaq (%rax,%r13,8), %r8
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xd67c
movl 0xc(%r14), %eax
movq %rbp, %r13
jmp 0x13908
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl 0x8(%rdi), %ebp
movl %ebp, 0xc(%rsi)
cmpl $0x1, %ebp
jle 0x13a59
leaq 0x10(%rsp), %r15
xorl %r12d, %r12d
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
xorl %esi, %esi
callq 0x21e0
movl 0x4(%r14), %eax
addl %eax, %eax
testl %eax, %eax
cmovlel %r12d, %eax
cmpq %r12, %rax
je 0x13a8b
movl %r12d, %ecx
shrl %ecx
movq 0x20(%r14), %rdx
movq 0x58(%r14), %rsi
movl (%rdx,%rcx,4), %ecx
decl %ecx
movq 0x60(%r14), %rdx
movzbl (%rdx,%r12), %edx
movzbl (%rsi,%r12), %esi
shll $0x2, %esi
shll $0x3, %edx
orl %esi, %edx
shlq $0x4, %rcx
addq %rsp, %rcx
addq $0x10, %rcx
incl (%rdx,%rcx)
incq %r12
jmp 0x13a19
movl 0x4(%r14), %eax
addl %eax, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x13adf
movq 0x58(%r14), %rdx
movq 0x60(%r14), %rsi
movzbl (%rsi,%rcx), %esi
movzbl (%rdx,%rcx), %edx
shll $0x2, %edx
shll $0x3, %esi
orl %edx, %esi
incl (%rsp,%rsi)
incq %rcx
jmp 0x13a66
xorl %eax, %eax
movslq %ebp, %rcx
cmpq %rcx, %rax
jge 0x13adf
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
cmpq $0x4, %rcx
je 0x13ad2
movl (%r15,%rcx,4), %edx
addl %edx, (%rsp,%rcx,4)
incq %rcx
jmp 0x13ac0
incq %rax
movl 0x8(%r14), %ebp
addq $0x10, %r15
jmp 0x13a8d
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 %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6101(%rip), %rsi      # 0x19c34
callq 0x1646f
movslq 0x4(%r12), %rdx
incq %rdx
leaq 0x60f3(%rip), %rsi      # 0x19c3a
movq %rbx, %rdi
callq 0x16315
movslq 0x4(%r12), %rax
movslq 0x8(%r12), %rdx
addq %rax, %rdx
leaq 0x587e(%rip), %rsi      # 0x193e1
movq %rbx, %rdi
callq 0x16315
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 0xd45d
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 0x6074(%rip), %rsi      # 0x19c3e
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1646f
leaq -0x30(%rbp), %rax
movq (%rax), %rsi
movslq (%r14), %r14
movq %r12, %rdi
movq %r14, %rdx
callq 0x2080
movb %r15b, (%r14,%r12)
leaq 0x604d(%rip), %rsi      # 0x19c42
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1646f
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_gen_tbl_line
int bgtm_gen_tbl_line(bgtm_t *bm, const bgt_info_t *ss, const bcf1_t *b)
{
	int i, type, err;
	kstring_t *s = &bm->tbl_line;
	bm->tbl_line.l = 0;
	for (i = 0; i < bm->n_fields; ++i) {
		int64_t vi;
		double vr;
		const char *vs;
		kexpr_t *e = bm->fields[i];
		if (i) kputc('\t', s);
		bgtm_assign_expr(e, ss);
		bgtm_assign_by_bcf(e, bm->h_out, b);
		err = ke_eval(e, &vi, &vr, &vs, &type);
		if (err) kputc('*', s);
		else if (type == KEV_INT) kputl(vi, s);
		else if (type == KEV_REAL) ksprintf(s, "%lg", vr);
		else if (type == KEV_STR) kputs(vs, s);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x78(%rdi), %r12
andq $0x0, 0x78(%rdi)
xorl %ebp, %ebp
pushq $0xa
popq %rbx
movslq 0x68(%r15), %rax
cmpq %rax, %rbp
jge 0x13dd5
movq 0x70(%r15), %rax
movq (%rax,%rbp,8), %r13
testq %rbp, %rbp
je 0x13c5b
pushq $0x9
popq %rdi
movq %r12, %rsi
callq 0x11b3c
movq %r13, %rdi
movq %r14, %rsi
callq 0x13766
movq 0x50(%r15), %rsi
movq %r13, %rdi
movq 0x10(%rsp), %rdx
callq 0x13b06
movq %r13, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %r8
callq 0x15f68
testl %eax, %eax
je 0x13ca7
pushq $0x2a
popq %rdi
movq %r12, %rsi
callq 0x11b3c
incq %rbp
jmp 0x13c36
movl 0xc(%rsp), %eax
cmpl $0x1, %eax
je 0x13da5
cmpl $0x3, %eax
je 0x13d93
cmpl $0x2, %eax
jne 0x13ca2
movq 0x28(%rsp), %rsi
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
xorl %r13d, %r13d
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
orb $0x30, %dl
movb %dl, 0x30(%rsp,%r13)
incq %r13
cmpq $0x9, %rcx
movq %rax, %rcx
ja 0x13cd4
testq %rsi, %rsi
jns 0x13d00
movl %r13d, %eax
incl %r13d
movb $0x2d, 0x30(%rsp,%rax)
movq 0x78(%r15), %rax
movslq %r13d, %rcx
addq %rcx, %rax
incq %rax
cmpq 0x80(%r15), %rax
jb 0x13d6d
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x10, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x80(%r15)
movq 0x88(%r15), %rdi
callq 0x2340
testq %rax, %rax
je 0x13ca2
movq %rax, 0x88(%r15)
movl %r13d, %eax
testl %eax, %eax
jle 0x13dc1
movb 0x2f(%rsp,%rax), %cl
decq %rax
movq 0x78(%r15), %rdx
movq 0x88(%r15), %rsi
leaq 0x1(%rdx), %rdi
movq %rdi, 0x78(%r15)
movb %cl, (%rsi,%rdx)
jmp 0x13d70
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x11b19
jmp 0x13ca2
movsd 0x20(%rsp), %xmm0
movq %r12, %rdi
leaq 0x5e91(%rip), %rsi      # 0x19c46
movb $0x1, %al
callq 0x135b3
jmp 0x13ca2
movq 0x78(%r15), %rax
movq 0x88(%r15), %rcx
movb $0x0, (%rcx,%rax)
jmp 0x13ca2
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_al_from_bcf
void bgt_al_from_bcf(const bcf_hdr_t *h, const bcf1_t *b, bgt_allele_t *a, bgt_allele_t *r)
{
	char *ref, *alt;
	const char *chr;
	int l_ref, l_alt, min_l, shift, l_chr;
	bcf_get_ref_alt1(b, &l_ref, &ref, &l_alt, &alt);
	min_l = l_ref < l_alt? l_ref : l_alt;
	for (shift = 0; shift < min_l && ref[shift] == alt[shift]; ++shift);
	a->rid = b->rid, a->pos = b->pos + shift, a->rlen = b->rlen - shift;
	a->chr.l = 0;
	chr = h->id[BCF_DT_CTG][b->rid].key;
	l_chr = strlen(chr);
	kputsn(chr, l_chr, &a->chr);
	kputc(0, &a->chr);
	kputsn(alt + shift, l_alt - shift, &a->chr);
	a->al = a->chr.s + l_chr + 1;
	if (r) {
		r->rid = b->rid, r->pos = b->pos + shift, r->rlen = b->rlen - shift;
		r->chr.l = 0;
		kputsn(chr, l_chr, &r->chr);
		kputc(0, &r->chr);
		kputsn(ref + shift, l_ref - shift, &r->chr);
		r->al = r->chr.s + l_chr + 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
leaq 0x4(%rsp), %r14
leaq 0x8(%rsp), %rdx
movq %rsp, %r13
leaq 0x20(%rsp), %rbp
movq %rsi, %rdi
movq %r14, %rsi
movq %r13, %rcx
movq %rbp, %r8
callq 0xd45d
movl (%r14), %eax
movl (%r13), %ebx
cmpl %ebx, %eax
cmovll %eax, %ebx
leaq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rbp), %rcx
xorl %r14d, %r14d
testl %ebx, %ebx
cmovlel %r14d, %ebx
cmpq %r14, %rbx
je 0x14277
movb (%rax,%r14), %dl
cmpb (%rcx,%r14), %dl
jne 0x1427c
incq %r14
jmp 0x14263
movq %rbx, %r14
jmp 0x1427f
movl %r14d, %ebx
movslq (%r15), %rax
movl %eax, 0x20(%r12)
movl 0x4(%r15), %ecx
addl %ebx, %ecx
movl %ecx, 0x24(%r12)
movl 0x8(%r15), %ecx
subl %ebx, %ecx
movl %ecx, 0x28(%r12)
andq $0x0, (%r12)
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
shlq $0x4, %rax
movq (%rcx,%rax), %r13
movq %r13, %rdi
callq 0x2170
movq %rax, %rbp
movq %r13, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x11a85
xorl %edi, %edi
movq %r12, %rsi
callq 0x11b3c
movq 0x20(%rsp), %rdi
addq %r14, %rdi
movl (%rsp), %esi
subl %ebx, %esi
movq %r12, %rdx
callq 0x11a85
movq 0x10(%r12), %rax
movslq %ebp, %rbp
addq %rbp, %rax
incq %rax
movq %rax, 0x18(%r12)
movq 0x18(%rsp), %r12
testq %r12, %r12
je 0x14367
movl (%r15), %eax
movl %eax, 0x20(%r12)
movl 0x4(%r15), %eax
addl %ebx, %eax
movl %eax, 0x24(%r12)
movl 0x8(%r15), %eax
subl %ebx, %eax
movl %eax, 0x28(%r12)
andq $0x0, (%r12)
movq %r13, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x11a85
xorl %edi, %edi
movq %r12, %rsi
callq 0x11b3c
addq 0x8(%rsp), %r14
movl 0x4(%rsp), %esi
subl %ebx, %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x11a85
movq 0x10(%r12), %rax
addq %rbp, %rax
incq %rax
movq %rax, 0x18(%r12)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1438f
movq %rbx, %rdi
callq 0x13173
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13de6
testl %eax, %eax
jg 0x1438f
movl %eax, %ebp
testb $0x2, 0xc(%rbx)
jne 0x143c0
movq 0x50(%rbx), %rdi
movl 0x4(%rbx), %edx
movq 0x28(%rbx), %r8
addq $0x58, %rbx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x11cb9
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_hapcnt_print_destroy
char *bgtm_hapcnt_print_destroy(const bgtm_t *bm, int n_hap, bgt_hapcnt_t *hc)
{
	int i, j;
	kstring_t s = {0,0,0};
	ksprintf(&s, "NA\t%d\n", bm->n_aal);
	for (i = 0; i < bm->n_aal; ++i) {
		bgt_allele_t *a = &bm->aal[i];
		ksprintf(&s, "AA\t%s:%d:%d:%s\n", a->chr.s, a->pos+1, a->rlen, a->al);
	}
	ksprintf(&s, "NH\t%d\t%d\n", n_hap, bm->n_groups);
	for (i = 0; i < n_hap; ++i) {
		kputs("HC\t", &s);
		for (j = 0; j < bm->n_aal; ++j)
			kputc('0' + (hc[i].hap>>j&1), &s);
		for (j = 0; j < bm->n_groups; ++j)
			ksprintf(&s, "\t%d", hc[i].cnt[j]);
		kputc('\n', &s);
		free(hc[i].cnt);
	}
	free(hc);
	return s.s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
movl 0x90(%rdi), %edx
leaq 0x4db3(%rip), %rsi      # 0x19c87
movq %r12, %rdi
xorl %eax, %eax
callq 0x135b3
pushq $0x28
popq %rbp
leaq 0x4da6(%rip), %r13      # 0x19c8e
xorl %r14d, %r14d
movslq 0x90(%r15), %rax
cmpq %rax, %r14
jge 0x14f28
movq 0x98(%r15), %rax
movl -0x4(%rax,%rbp), %ecx
incl %ecx
movl (%rax,%rbp), %r8d
movq -0x18(%rax,%rbp), %rdx
movq -0x10(%rax,%rbp), %r9
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x135b3
incq %r14
addq $0x30, %rbp
jmp 0x14eeb
movl 0x8(%r15), %ecx
leaq 0x4d6b(%rip), %rsi      # 0x19c9e
xorl %ebx, %ebx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq 0x8(%rsp), %r14
movl %r14d, %edx
xorl %eax, %eax
callq 0x135b3
testl %r14d, %r14d
cmovlel %ebx, %r14d
movq %r14, 0x8(%rsp)
leaq 0x4d4d(%rip), %rbp      # 0x19cac
xorl %ebx, %ebx
cmpq 0x8(%rsp), %rbx
je 0x15007
leaq 0x4d35(%rip), %rdi      # 0x19ca8
movq %r12, %rsi
callq 0x11b19
movq %rbx, 0x18(%rsp)
imulq $0x18, %rbx, %r14
movq 0x10(%rsp), %rax
leaq (%rax,%r14), %rbx
xorl %r13d, %r13d
movslq 0x90(%r15), %rax
cmpq %rax, %r13
jge 0x14fb8
movq (%rbx), %rax
btq %r13, %rax
movl $0x0, %edi
adcl $0x30, %edi
movq %r12, %rsi
callq 0x11b3c
incq %r13
jmp 0x14f90
movq 0x10(%rsp), %rax
addq %rax, %r14
addq $0x10, %r14
xorl %ebx, %ebx
movslq 0x8(%r15), %rax
cmpq %rax, %rbx
jge 0x14fe7
movq (%r14), %rax
movl (%rax,%rbx,4), %edx
movq %r12, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x135b3
incq %rbx
jmp 0x14fc6
pushq $0xa
popq %rdi
movq %r12, %rsi
callq 0x11b3c
movq (%r14), %rdi
callq 0x2050
movq 0x18(%rsp), %rbx
incq %rbx
jmp 0x14f61
movq 0x10(%rsp), %rdi
callq 0x2050
movq 0x30(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
movq %rsp, %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x4c67(%rip), %r15      # 0x19cb0
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0x150b0
movq 0xa8(%rbx), %rax
movl (%rax,%r12,4), %eax
cmpl 0x90(%rbx), %eax
jne 0x150ab
movq 0x28(%rbx), %rax
cmpl $0x1, (%rax,%r12,4)
jg 0x150ab
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
imulq $0x18, %rax, %rax
movq (%rdx,%rax), %rdx
incl %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x135b3
incq %r12
jmp 0x1504c
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16314
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r15
jge 0x16302
movq 0x8(%rdi,%r14), %rdi
callq 0x2050
movq 0x8(%rbx), %rax
movq 0x28(%rax,%r14), %rdi
callq 0x2050
incq %r15
addq $0x30, %r14
jmp 0x162d5
callq 0x2050
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %r14
movq %rdx, 0x10(%rsp)
cvtsi2sd %rdx, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movl $0x0, 0x4(%rsp)
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x163a9
movq 0x8(%r15), %rbx
movq (%rbx,%r12), %rbp
cmpw $0x1, %bp
jne 0x163a0
movq 0x8(%rbx,%r12), %rdi
testq %rdi, %rdi
je 0x163a0
movq %r14, %rsi
callq 0x2230
testl %eax, %eax
jne 0x163a0
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
addq $0x30, %r12
jmp 0x16347
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_O2/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, %rbx
movsd 0x2a6b(%rip), %xmm1     # 0x18e40
movsd %xmm0, 0x10(%rsp)
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, 0x8(%rsp)
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movl $0x0, 0x4(%rsp)
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x1645c
movq 0x8(%r14), %r15
movq (%r15,%r12), %rbp
cmpw $0x1, %bp
jne 0x16453
movq 0x8(%r15,%r12), %rdi
testq %rdi, %rdi
je 0x16453
movq %rbx, %rsi
callq 0x2230
testl %eax, %eax
jne 0x16453
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%r15,%r12)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r15,%r12)
andq $-0x7ffffff, %rbp       # imm = 0xF8000001
orq $0x4010000, %rbp        # imm = 0x4010000
movq %rbp, (%r15,%r12)
incl 0x4(%rsp)
incq %r13
addq $0x30, %r12
jmp 0x163fa
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_O2/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)
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movl $0x0, 0xc(%rsp)
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x16515
movq 0x8(%r15), %rbx
movq (%rbx,%r12), %rbp
cmpw $0x1, %bp
jne 0x1650c
movq 0x8(%rbx,%r12), %rdi
testq %rdi, %rdi
je 0x1650c
movq %r14, %rsi
callq 0x2230
testl %eax, %eax
jne 0x1650c
movl %ebp, %eax
andl $0x3ff0000, %eax        # imm = 0x3FF0000
cmpl $0x30000, %eax          # imm = 0x30000
jne 0x164de
movq 0x28(%rbx,%r12), %rdi
callq 0x2050
movq (%rbx,%r12), %rbp
movq 0x10(%rsp), %rdi
callq 0x2430
movq %rax, 0x28(%rbx,%r12)
andq $-0x7ff0001, %rbp       # imm = 0xF800FFFF
orq $0x4030000, %rbp        # imm = 0x4030000
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx,%r12)
movq %rbp, (%rbx,%r12)
incl 0xc(%rsp)
incq %r13
addq $0x30, %r12
jmp 0x16496
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_O2/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)
movq %rdi, %r15
xorl %r12d, %r12d
movabsq $-0xffffff0001, %rbx    # imm = 0xFFFFFF000000FFFF
movabsq $0x10000000003, %rdx    # imm = 0x10000000003
xorl %ebp, %ebp
movl $0x0, 0x4(%rsp)
movslq (%r15), %rax
cmpq %rax, %rbp
jge 0x165cb
movq 0x8(%r15), %r14
movq (%r14,%r12), %r13
movq %r13, %rax
andq %rbx, %rax
cmpq %rdx, %rax
jne 0x165c2
movq 0x8(%r14,%r12), %rdi
movq 0x10(%rsp), %rsi
callq 0x2230
testl %eax, %eax
jne 0x165b8
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
addq $0x30, %r12
jmp 0x16564
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_O2/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)
movq %rdi, %r15
xorl %r12d, %r12d
movabsq $-0xffffff0001, %rbx    # imm = 0xFFFFFF000000FFFF
movabsq $0x20000000003, %rdx    # imm = 0x20000000003
xorl %ebp, %ebp
movl $0x0, 0x4(%rsp)
movslq (%r15), %rax
cmpq %rax, %rbp
jge 0x16681
movq 0x8(%r15), %r14
movq (%r14,%r12), %r13
movq %r13, %rax
andq %rbx, %rax
cmpq %rdx, %rax
jne 0x16678
movq 0x8(%r14,%r12), %rdi
movq 0x10(%rsp), %rsi
callq 0x2230
testl %eax, %eax
jne 0x1666e
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
addq $0x30, %r12
jmp 0x1661a
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_O2/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 0x379b(%rip), %rsi      # 0x19e40
movq 0xa944(%rip), %rdx      # 0x20ff0
callq 0x16528
movl %eax, %ebp
leaq 0x378a(%rip), %rsi      # 0x19e44
movq 0xa8df(%rip), %rdx      # 0x20fa0
movq %rbx, %rdi
callq 0x16528
movl %eax, %r14d
addl %ebp, %r14d
leaq 0x3772(%rip), %rsi      # 0x19e48
movq 0xa8db(%rip), %rdx      # 0x20fb8
movq %rbx, %rdi
callq 0x16528
movl %eax, %r15d
leaq 0x375f(%rip), %rsi      # 0x19e4e
movq 0xa8ea(%rip), %rdx      # 0x20fe0
movq %rbx, %rdi
callq 0x16528
movl %eax, %ebp
addl %r15d, %ebp
addl %r14d, %ebp
leaq 0x3746(%rip), %rsi      # 0x19e53
movq 0xa8bc(%rip), %rdx      # 0x20fd0
movq %rbx, %rdi
callq 0x16528
movl %eax, %r14d
leaq 0x3731(%rip), %rsi      # 0x19e57
movq 0xa87b(%rip), %rdx      # 0x20fa8
movq %rbx, %rdi
callq 0x16528
movl %eax, %r15d
addl %r14d, %r15d
leaq 0x3719(%rip), %rsi      # 0x19e5b
movq 0xa87f(%rip), %rdx      # 0x20fc8
movq %rbx, %rdi
callq 0x16528
movl %eax, %r14d
addl %r15d, %r14d
addl %ebp, %r14d
leaq 0x36fe(%rip), %rsi      # 0x19e5f
movq 0xa828(%rip), %rdx      # 0x20f90
movq %rbx, %rdi
callq 0x165de
addl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
xorl %ecx, %ecx
movslq (%rdi), %rdx
cmpq %rdx, %rcx
jge 0x167b4
movq 0x8(%rdi), %rdx
movq (%rdx,%rax), %rsi
cmpw $0x1, %si
jne 0x167ab
cmpq $0x0, 0x8(%rdx,%rax)
je 0x167ab
andq $-0x400ffff, %rsi       # imm = 0xFBFF0001
movq %rsi, (%rdx,%rax)
incq %rcx
addq $0x30, %rax
jmp 0x16782
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x168be
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3575(%rip), %r13      # 0x19d48
pushq $0x20
popq %r12
xorl %ebp, %ebp
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x168a8
movq 0x8(%rbx), %r15
testq %rbp, %rbp
je 0x167f9
movl %r12d, %edi
callq 0x2060
movq (%r15,%rbp), %rdx
cmpw $0x3, %dx
je 0x16869
movzwl %dx, %eax
cmpl $0x2, %eax
je 0x16849
cmpl $0x1, %eax
jne 0x16880
movq 0x8(%r15,%rbp), %rsi
testq %rsi, %rsi
jne 0x16859
shrl $0x10, %edx
andl $0x3ff, %edx            # imm = 0x3FF
cmpl $0x3, %edx
je 0x1689a
cmpl $0x2, %edx
je 0x1688c
cmpl $0x1, %edx
jne 0x16880
movsd 0x18(%r15,%rbp), %xmm0
leaq 0x2884(%rip), %rdi      # 0x190c4
movb $0x1, %al
callq 0x2190
jmp 0x16880
shrq $0x20, %rdx
movsbq %dl, %rax
movslq (%r13,%rax,4), %rsi
addq %r13, %rsi
leaq 0x3603(%rip), %rdi      # 0x19e63
xorl %eax, %eax
callq 0x2190
jmp 0x16880
movq 0x8(%r15,%rbp), %rsi
sarq $0x28, %rdx
leaq 0x35f2(%rip), %rdi      # 0x19e6b
xorl %eax, %eax
callq 0x2190
incq %r14
addq $0x30, %rbp
jmp 0x167dc
movq 0x20(%r15,%rbp), %rsi
leaq 0x2827(%rip), %rdi      # 0x190bf
jmp 0x16860
movq 0x28(%r15,%rbp), %rsi
leaq 0x35c0(%rip), %rdi      # 0x19e66
jmp 0x16860
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x3f10
leaq 0x58(%r14), %rax
andl $0x0, 0x58(%r14)
andq $0x0, 0x60(%r14)
movq %rax, 0x68(%r14)
movq %rax, 0x70(%r14)
andq $0x0, 0x78(%r14)
movb %bpl, (%r14)
movq %r15, 0x8(%r14)
movb $0x0, 0x1(%r14)
movl $0xa0, %edi
callq 0x2030
movq %rax, 0x80(%r14)
pushq $0x1
popq %r12
pushq $-0x1
popq %r13
cmpq $0x14, %r12
je 0x265d
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %r13, %rdi
testl %eax, %eax
js 0x2648
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2030
movq 0x80(%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x262b
pushq $0x50
popq %rdi
callq 0x2030
movq %rax, 0x88(%r14)
pushq $0x50
popq %rdi
callq 0x2030
movq %rax, 0x90(%r14)
movl $0xa0, %edi
callq 0x2030
movq %rax, 0x98(%r14)
movzbl %bpl, %esi
movq %r15, %rdi
callq 0x3d38
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26a9
movq %rax, %r15
addq $0x50, %r14
movq %r14, %rdi
callq 0x2e5c
movq %rbx, %rdi
callq 0x3f1e
movq %r15, %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r14
movq 0x80(%rbx), %rdi
cmpq $0x14, %r14
je 0x26f3
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x26ee
callq 0x2230
incq %r14
jmp 0x26d3
testq %rdi, %rdi
je 0x26fd
callq 0x2230
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x270e
callq 0x2230
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x271f
callq 0x2230
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x2730
callq 0x2230
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x3f34
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x2e5c
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3f1e
movq %rax, %rdi
callq 0x2d6e
nop
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x98(%rdi), %rax
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
cmpq %rcx, %rsi
je 0x2782
movsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x276e
movb $0x1, 0x1(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
andl $0x0, 0x14(%rdi)
addq $0x18, %rdi
callq 0x3f8a
xorl %r12d, %r12d
pushq $0x1
popq %rbp
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpl %eax, %r14d
jge 0x285a
cmpb $0x1, 0x1(%rbx)
jne 0x27d9
movq 0x98(%rbx), %rax
movsd (%rax), %xmm0
callq 0x6ec0
testb %al, %al
je 0x2852
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
andl $0x0, 0x4(%rcx)
movq 0x80(%rbx), %rdx
testl %eax, %eax
cmovlel %r12d, %eax
xorl %esi, %esi
cmpq %rsi, %rax
je 0x2844
movl (%r15,%rsi,4), %edi
cmpl %r14d, %edi
jle 0x283f
movq 0x8(%rdx), %r8
movslq 0x4(%rcx), %r9
leal 0x1(%r9), %r10d
movl %r10d, 0x4(%rcx)
movl %edi, (%r8,%r9,4)
incq %rsi
jmp 0x281d
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2864
incl %r14d
jmp 0x27ac
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0xa0(%rdi), %r12
movl 0x10(%rdi), %esi
movq %r12, %rdi
callq 0x3e0c
movb $0x0, 0x231(%r14)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
callq 0x2d7a
leaq 0x231(%r14), %r12
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x44c4
leaq 0x28(%rsp), %rdi
callq 0x20c0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0x2d7a
addq $0x50, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2db6
addl %ebx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x20c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2bc4
jmp 0x2bcb
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20c0
jmp 0x2bce
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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 0x2bd6
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq 0x68(%r14), %r13
addq $0x58, %r14
leaq 0x50(%rsp), %r12
leaq 0x30(%rsp), %rbp
leaq 0x8(%rsp), %r15
cmpq %r14, %r13
je 0x2d11
leaq 0x20(%r13), %rsi
movq %rbp, %rdi
callq 0x2e1c
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x2ec0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33b4
leaq 0x10(%rsp), %rdi
callq 0x20c0
movq %rbp, %rdi
callq 0x20c0
movq %r13, %rdi
callq 0x20f0
movq %rax, %r13
jmp 0x2cc8
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x35af
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3d04
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d3d
movq %rax, %r14
jmp 0x2d5e
movq %rax, %r14
jmp 0x2d54
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20c0
leaq 0x30(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2e3a
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r13d, %r13d
testl %edx, %edx
cmovgl %edx, %r13d
cmpb $0x0, 0xf550(%rip)      # 0x132b8
je 0x3dbe
addq %r13, %r13
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq %r12, %r13
je 0x3ded
movq 0xf531(%rip), %rdi      # 0x132b0
movl (%r14,%r12,2), %esi
movq (%rdi), %rax
movl %ebx, %edx
callq *0x48(%rax)
movzbl %al, %ebp
movl %r12d, %ecx
shlq %cl, %rbp
movq 0xf515(%rip), %rdi      # 0x132b0
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
jmp 0x3d73
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq %r12, %r13
je 0x3ded
movq 0xf4e0(%rip), %rdi      # 0x132b0
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
jmp 0x3dc4
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_O2/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:
movl %esi, %eax
imull %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x3e21
movb $0x30, (%rdi,%rcx)
incq %rcx
jmp 0x3e13
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movb $0x0, (%rdi,%rax)
movslq %esi, %rsi
leaq -0x1(%rsi), %r8
imulq %rsi, %r8
addq %rdi, %r8
movq %rsi, %rax
negq %rax
movq %rax, -0x8(%rsp)
addq %rsi, %rdi
decq %rdi
xorl %eax, %eax
movabsq $0x1, %r11
movl $0x2, %ebx
movl $0x1, %r10d
movq %rsi, %r14
cmpq $0x2, %r14
jl 0x3f02
decq %r14
movl %eax, -0xc(%rsp)
movl %eax, %r15d
xorl %r12d, %r12d
movq %rdi, %r13
movq %r15, %rax
xorl %r9d, %r9d
cmpq %r14, %r12
jge 0x3eee
cmpb $0x1, 0xf424(%rip)      # 0x132b8
jne 0x3ec1
movq %r11, %rbp
movl %eax, %ecx
shlq %cl, %rbp
testq %rdx, %rbp
setg %cl
orb $0x30, %cl
movb %cl, (%r13)
leal 0x1(%rax), %ecx
movq %r11, %rbp
shlq %cl, %rbp
testq %rdx, %rbp
setg %cl
orb $0x30, %cl
movl %ebx, %ebp
jmp 0x3edb
leal (%r15,%r12), %ecx
movq %r11, %rbp
shlq %cl, %rbp
testq %rdx, %rbp
setg %cl
orb $0x30, %cl
movb %cl, (%r13)
movl %r10d, %ebp
movb %cl, (%r8,%r12)
addl %ebp, %r9d
incq %r12
addq $0x2, %rax
addq %rsi, %r13
jmp 0x3e88
movl -0xc(%rsp), %eax
addl %r9d, %eax
addq -0x8(%rsp), %r8
decq %rdi
jmp 0x3e68
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x3f89
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq %eax, %rcx
movq 0x8(%rbx), %rdi
cmpq %rcx, %r14
jge 0x3f67
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x3f62
callq 0x2230
movl 0x4(%rbx), %eax
incq %r14
jmp 0x3f45
callq 0x21f0
movq 0x10(%rbx), %rdi
callq 0x21f0
movq 0x18(%rbx), %rdi
callq 0x21f0
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
imull $0xa, %esi, %eax
movl %eax, (%rdi)
pushq $0x1
popq %rbp
movl %ebp, 0x4(%rdi)
movslq %eax, %r14
leaq (,%r14,8), %rdi
callq 0x2250
movq %rax, %r15
movq %rax, 0x8(%rbx)
shlq $0x2, %r14
movq %r14, %rdi
callq 0x2250
movq %rax, %r12
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x2250
movq %rax, %r14
movq %rax, 0x18(%rbx)
pushq $0x40
popq %rdi
callq 0x2030
movq %rax, (%r15)
movl %ebp, (%r12)
andl $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
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/IGtrie.cpp
// Function: IGtrie::insertLabel(int, long long, int)
int IGtrie::insertLabel(int labelNode, long long int label, int digits)
{
  if (labelPaths[labelNode][label & (LB_WORD_SIZE - 1)] == -1)
  {
    if (numLabels == maxLabels)
      expand();

    int newNode = numLabels++;
    labelPaths[newNode] = new int[LB_WORD_SIZE];
    memset(labelPaths[newNode], -1, sizeof(int) * LB_WORD_SIZE);
    labelPaths[labelNode][label & (LB_WORD_SIZE - 1)] = newNode;
    labelLeaf[newNode] = ((digits <= LB_WORD_LEN) ? digits : 0);
    labelCount[newNode] = 0;
  }

  int nextNode = labelPaths[labelNode][label & (LB_WORD_SIZE - 1)];

  if (!labelLeaf[nextNode])
    return insertLabel(nextNode, label >> LB_WORD_LEN, digits - LB_WORD_LEN);
  return nextNode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %eax
movq %rdi, %r15
movq 0x8(%rdi), %rbx
movslq %eax, %r12
movq (%rbx,%r12,8), %rax
movl %r14d, %ebp
andl $0xf, %ebp
movl %ebp, %edx
movl (%rax,%rdx,4), %eax
cmpl $-0x1, %eax
je 0x409b
movq 0x10(%r15), %r8
jmp 0x411b
movl %ecx, 0x4(%rsp)
movl 0x4(%r15), %r13d
cmpl (%r15), %r13d
jne 0x40b8
movq %r15, %rdi
callq 0x4010
movl 0x4(%r15), %r13d
movq 0x8(%r15), %rbx
leal 0x1(%r13), %eax
movl %eax, 0x4(%r15)
pushq $0x40
popq %rdi
callq 0x2030
movslq %r13d, %rdx
movq %rax, (%rbx,%rdx,8)
movq 0x8(%r15), %rax
movq (%rax,%rdx,8), %rax
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x30(%rax)
movdqu %xmm0, 0x20(%rax)
movdqu %xmm0, 0x10(%rax)
movdqu %xmm0, (%rax)
movq 0x8(%r15), %rbx
movq (%rbx,%r12,8), %rax
movl 0x4(%rsp), %ecx
cmpl $0x5, %ecx
movl $0x0, %esi
cmovll %ecx, %esi
movl %edx, (%rax,%rbp,4)
movq 0x10(%r15), %r8
movl %esi, (%r8,%rdx,4)
movq 0x18(%r15), %rsi
andl $0x0, (%rsi,%rdx,4)
movl (%rax,%rbp,4), %eax
movslq %eax, %rdx
cmpl $0x0, (%r8,%rdx,4)
jne 0x4131
sarq $0x4, %r14
addl $-0x4, %ecx
jmp 0x407b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/IGtrie.cpp
// Function: IGtrie::enumerateFrom(int, long long, long long, int, int)
void IGtrie::enumerateFrom(int currentNode, long long int label, long long int parLabel, int parSize, int remaining)
{
  if (remaining == 0)
  {
    enumeration.push_back(make_pair(label, labelCount[currentNode]));
    return;
  }

  int i;
  for (i = 0; i < LB_WORD_SIZE; i++)
    if (labelPaths[currentNode][i] != -1)
    {
      long long int tmpLabel = parLabel;
      int tmpSize = parSize;

      if (labelLeaf[labelPaths[currentNode][i]])
      {
        int digits = labelLeaf[labelPaths[currentNode][i]];
        tmpLabel |= (i << tmpSize);
        tmpSize += digits;
        enumerateFrom(labelPaths[currentNode][i], ((label << tmpSize) | tmpLabel), 0, 0, remaining - 1);
      }
      else
      {
        int digits = LB_WORD_LEN;
        tmpLabel |= (i << tmpSize);
        tmpSize += digits;
        enumerateFrom(labelPaths[currentNode][i], label, tmpLabel, tmpSize, remaining);
      }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
testl %r9d, %r9d
je 0x4235
movl %r8d, %r12d
movq %rcx, %r13
movslq %esi, %r15
movq %r9, 0x10(%rsp)
leal -0x1(%r9), %eax
movl %eax, 0xc(%rsp)
leal 0x4(%r12), %eax
movl %eax, 0x8(%rsp)
xorl %ebp, %ebp
cmpq $0x10, %rbp
je 0x4256
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movslq (%rax,%rbp,4), %rsi
cmpq $-0x1, %rsi
je 0x4230
movl %ebp, %eax
movl %r12d, %ecx
shll %cl, %eax
movq 0x10(%rbx), %rcx
movl (%rcx,%rsi,4), %ecx
cltq
testl %ecx, %ecx
je 0x4215
addl %r12d, %ecx
movq %r14, %rdx
shlq %cl, %rdx
orq %r13, %rax
orq %rdx, %rax
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl 0xc(%rsp), %r9d
jmp 0x422b
orq %r13, %rax
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
movl 0x8(%rsp), %r8d
movq 0x10(%rsp), %r9
callq 0x4186
incq %rbp
jmp 0x41c4
movq 0x18(%rbx), %rax
addq $0x20, %rbx
movslq %esi, %rcx
movl (%rax,%rcx,4), %eax
leaq 0x18(%rsp), %rsi
movq %r14, (%rsi)
movl %eax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x431c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/Isomorphism.cpp
// Function: Isomorphism::canonicalStrNauty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char*)
void Isomorphism::canonicalStrNauty(std::string v, char *s) {

  int i, j, aux;

  for (int i=0; i<n; i++) {
    gv = GRAPHROW(g,i,m);
    EMPTYSET(gv,m);

    for (int j=0; j<n; j++)
      if(v[i*n + j] == '1')
        ADDELEMENT(gv,j);
  }

  nauty(g,lab,ptn,NULL,orbits,&options,&stats,
        workspace,WORKSPACE_SIZE,m,n,mm);
  
  aux=0;
  for (i=0; i<n; i++) {
    gv = GRAPHROW(mm,i,m); 
    for (j=0; j<n; j++)
      s[aux++] = ISELEMENT(gv,j)?'1':'0';
  }
  s[aux]=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
addq $0x4c80, %rdi           # imm = 0x4C80
movl 0x4b04(%r14), %r10d
leaq 0x4c7c(%r14), %rax
pushq $0x4
popq %rcx
xorl %edx, %edx
leaq 0x7b5a(%rip), %r15      # 0xc050
movslq %r10d, %r8
cmpq %r8, %rdx
jge 0x4574
movslq 0x4b08(%r14), %r9
movq %rdx, %r8
imulq %r9, %r8
leaq (%rdi,%r8,4), %r8
movq %r8, 0x4c78(%r14)
imulq %rcx, %r9
addq %rax, %r9
cmpq %r8, %r9
jb 0x452d
andl $0x0, (%r9)
addq $-0x4, %r9
jmp 0x451e
xorl %r9d, %r9d
movl 0x4b04(%r14), %r10d
cmpl %r10d, %r9d
jge 0x456b
imull %edx, %r10d
addl %r9d, %r10d
movslq %r10d, %r10
movq (%rsi), %r11
cmpb $0x31, (%r11,%r10)
jne 0x4566
movl %r9d, %r10d
andl $0x1f, %r10d
movl (%r15,%r10,4), %r10d
movl %r9d, %r11d
shrl $0x5, %r11d
orl %r10d, (%r8,%r11,4)
incl %r9d
jmp 0x4530
incq %rdx
addq $0x4, %rcx
jmp 0x44f6
leaq 0x4b0c(%r14), %rsi
leaq 0x4b84(%r14), %rdx
leaq 0x4bfc(%r14), %r8
leaq 0x4(%r14), %rax
movl 0x4b08(%r14), %r11d
movq %fs:0x0, %rcx
leaq -0x80(%rcx), %r12
leaq 0xed1d(%rip), %rbp      # 0x132c8
leaq 0xec1e(%rip), %r9       # 0x131d0
xorl %r13d, %r13d
xorl %ecx, %ecx
pushq %r12
pushq %r10
pushq %r11
pushq $0x12c0                 # imm = 0x12C0
pushq %rax
pushq %rbp
callq 0x6ef4
addq $0x30, %rsp
movl 0x4b04(%r14), %ecx
xorl %eax, %eax
movslq %ecx, %rsi
movslq %eax, %rdx
cmpq %rsi, %r13
jge 0x4637
movslq 0x4b08(%r14), %rsi
imulq %r13, %rsi
leaq (%r12,%rsi,4), %rsi
movq %rsi, 0x4c78(%r14)
addq %rbx, %rdx
xorl %esi, %esi
cmpl %ecx, %esi
jge 0x4630
movq 0x4c78(%r14), %rcx
movl %esi, %edi
shrl $0x5, %edi
movl %esi, %r8d
andl $0x1f, %r8d
movl (%r15,%r8,4), %r8d
testl %r8d, (%rcx,%rdi,4)
sete %cl
xorb $0x31, %cl
movb %cl, (%rdx,%rsi)
movl 0x4b04(%r14), %ecx
incq %rsi
jmp 0x45fc
addl %esi, %eax
incq %r13
jmp 0x45d6
movb $0x0, (%rbx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop