LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/em.c
// Function: est_freq
static double est_freq(int n, const double *pdg)
{
	int i, gcnt[3], tmp1;
	// get a rough estimate of the genotype frequency
	gcnt[0] = gcnt[1] = gcnt[2] = 0;
	for (i = 0; i < n; ++i) {
		const double *p = pdg + i * 3;
		if (p[0] != 1. || p[1] != 1. || p[2] != 1.) {
			int which = p[0] > p[1]? 0 : 1;
			which = p[which] > p[2]? which : 2;
			++gcnt[which];
		}
	}
	tmp1 = gcnt[0] + gcnt[1] + gcnt[2];
	return (tmp1 == 0)? -1.0 : (.5 * gcnt[1] + gcnt[2]) / tmp1;
}

// Assembly:
movl $0x0, -0x4(%rsp)
movq $0x0, -0xc(%rsp)
testl %edi, %edi
jle 0x158cc
movl %edi, %eax
addq $0x10, %rsi
movsd 0x380c(%rip), %xmm0     # 0x19078
movl $0x2, %ecx
movsd -0x10(%rsi), %xmm1
movsd -0x8(%rsi), %xmm2
ucomisd %xmm0, %xmm1
jne 0x1589b
jp 0x1589b
ucomisd %xmm0, %xmm2
jne 0x1589b
jp 0x1589b
movsd (%rsi), %xmm2
ucomisd %xmm0, %xmm2
movapd %xmm0, %xmm2
jne 0x1589b
jnp 0x158b5
xorl %edx, %edx
ucomisd %xmm2, %xmm1
setbe %dl
movsd -0x10(%rsi,%rdx,8), %xmm1
ucomisd (%rsi), %xmm1
cmovbel %ecx, %edx
incl -0xc(%rsp,%rdx,4)
addq $0x18, %rsi
decq %rax
jne 0x15871
movl -0xc(%rsp), %eax
movl -0x8(%rsp), %edx
movl -0x4(%rsp), %ecx
jmp 0x158d2
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
addl %edx, %eax
addl %ecx, %eax
je 0x158fe
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd 0x3792(%rip), %xmm0     # 0x19080
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
retq
movsd 0x3792(%rip), %xmm0     # 0x19098
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/em.c
// Function: freqml
static double freqml(double f0, int beg, int end, const double *pdg)
{
	int i;
	double f;
	for (i = 0, f = f0; i < ITER_TRY; ++i)
		if (freq_iter(&f, pdg, beg, end) < EPS) break;
	if (i == ITER_TRY) { // haven't converged yet; try Brent's method
		minaux1_t a;
		a.beg = beg; a.end = end; a.pdg = pdg;
		kmin_brent(prob1, f0 == f? .5*f0 : f0, f, (void*)&a, EPS, &f);
	}
	return f;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edi, %eax
movl %esi, %ecx
subl %edi, %ecx
addl %ecx, %ecx
cvtsi2sd %ecx, %xmm2
leaq (%rax,%rax,2), %rcx
xorl %eax, %eax
movsd 0x3752(%rip), %xmm3     # 0x19078
movapd 0x5e52(%rip), %xmm4     # 0x1b780
movsd 0x5e5a(%rip), %xmm5     # 0x1b790
movapd %xmm0, %xmm6
xorpd %xmm1, %xmm1
cmpl %edi, %esi
jle 0x159dd
movapd %xmm3, %xmm7
subsd %xmm6, %xmm7
movapd %xmm7, %xmm8
mulsd %xmm7, %xmm8
movapd %xmm6, %xmm1
addsd %xmm6, %xmm1
unpcklpd %xmm6, %xmm1            # xmm1 = xmm1[0],xmm6[0]
unpcklpd %xmm6, %xmm7            # xmm7 = xmm7[0],xmm6[0]
mulpd %xmm1, %xmm7
movapd %xmm7, %xmm9
unpckhpd %xmm7, %xmm9            # xmm9 = xmm9[1],xmm7[1]
xorpd %xmm1, %xmm1
movq %rcx, %r8
movl %edi, %r9d
movl %r8d, %r10d
movupd 0x8(%rdx,%r10,8), %xmm10
movapd %xmm10, %xmm11
unpckhpd %xmm10, %xmm11          # xmm11 = xmm11[1],xmm10[1]
addsd %xmm11, %xmm11
mulpd %xmm7, %xmm10
mulsd %xmm9, %xmm11
movsd (%rdx,%r10,8), %xmm12
mulsd %xmm8, %xmm12
addsd %xmm10, %xmm12
unpcklpd %xmm12, %xmm11          # xmm11 = xmm11[0],xmm12[0]
addpd %xmm10, %xmm11
movapd %xmm11, %xmm10
unpckhpd %xmm11, %xmm10          # xmm10 = xmm10[1],xmm11[1]
divsd %xmm10, %xmm11
addsd %xmm11, %xmm1
incl %r9d
addq $0x3, %r8
cmpl %esi, %r9d
jl 0x15980
divsd %xmm2, %xmm1
movapd %xmm1, %xmm7
subsd %xmm6, %xmm7
andpd %xmm4, %xmm7
ucomisd %xmm7, %xmm5
ja 0x15a0a
incl %eax
movapd %xmm1, %xmm6
cmpl $0xa, %eax
jne 0x1593a
movsd %xmm1, 0x8(%rsp)
jmp 0x15a15
movsd %xmm1, 0x8(%rsp)
cmpl $0xa, %eax
jne 0x15a6b
leaq 0x10(%rsp), %rax
movl %edi, (%rax)
movl %esi, 0x4(%rax)
movq %rdx, 0x8(%rax)
movsd 0x3655(%rip), %xmm2     # 0x19080
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm3
cmpeqsd %xmm0, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm0, %xmm3
orpd %xmm2, %xmm3
leaq 0x546(%rip), %rdi       # 0x15f91
movsd 0x5d3d(%rip), %xmm2     # 0x1b790
leaq 0x8(%rsp), %rbx
movapd %xmm3, %xmm0
movq %rax, %rsi
movq %rbx, %rdx
callq 0x16c09
movsd (%rbx), %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/em.c
// Function: g3_iter
static double g3_iter(double g[3], const double *_pdg, int beg, int end)
{
	double err, gg[3];
	int i;
	gg[0] = gg[1] = gg[2] = 0.;
//	printf("%lg,%lg,%lg\n", g[0], g[1], g[2]);
	for (i = beg; i < end; ++i) {
		double sum, tmp[3];
		const double *pdg = _pdg + i * 3;
		tmp[0] = pdg[0] * g[0]; tmp[1] = pdg[1] * g[1]; tmp[2] = pdg[2] * g[2];
		sum = (tmp[0] + tmp[1] + tmp[2]) * (end - beg);
		gg[0] += tmp[0] / sum; gg[1] += tmp[1] / sum; gg[2] += tmp[2] / sum;
	}
	err = fabs(gg[0] - g[0]) > fabs(gg[1] - g[1])? fabs(gg[0] - g[0]) : fabs(gg[1] - g[1]);
	err = err > fabs(gg[2] - g[2])? err : fabs(gg[2] - g[2]);
	g[0] = gg[0]; g[1] = gg[1]; g[2] = gg[2];
	return err;
}

// Assembly:
movl %ecx, %eax
movupd (%rdi), %xmm2
movsd 0x10(%rdi), %xmm1
subl %edx, %eax
jle 0x15ae9
cvtsi2sd %eax, %xmm0
movslq %edx, %rdx
movslq %ecx, %rax
leaq (%rdx,%rdx,2), %rcx
leaq (%rsi,%rcx,8), %rcx
addq $0x10, %rcx
subq %rdx, %rax
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
movsd (%rcx), %xmm5
movupd -0x10(%rcx), %xmm6
mulpd %xmm2, %xmm6
mulsd %xmm1, %xmm5
movapd %xmm6, %xmm7
unpckhpd %xmm6, %xmm7            # xmm7 = xmm7[1],xmm6[1]
addsd %xmm6, %xmm7
addsd %xmm5, %xmm7
mulsd %xmm0, %xmm7
divsd %xmm7, %xmm5
unpcklpd %xmm7, %xmm7            # xmm7 = xmm7[0,0]
divpd %xmm7, %xmm6
addpd %xmm6, %xmm3
addsd %xmm5, %xmm4
addq $0x18, %rcx
decq %rax
jne 0x15aa5
jmp 0x15af1
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
movapd %xmm3, %xmm0
subpd %xmm2, %xmm0
movapd 0x5c7f(%rip), %xmm2     # 0x1b780
andpd %xmm2, %xmm0
pshufd $0xee, %xmm0, %xmm5     # xmm5 = xmm0[2,3,2,3]
maxsd %xmm5, %xmm0
movapd %xmm4, %xmm5
subsd %xmm1, %xmm5
andpd %xmm2, %xmm5
maxsd %xmm5, %xmm0
movupd %xmm3, (%rdi)
movsd %xmm4, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/em.c
// Function: lk_ratio_test
static double lk_ratio_test(int n, int n1, const double *pdg, double f3[3][3])
{
	double r;
	int i;
	for (i = 0, r = 1.; i < n1; ++i) {
		const double *p = pdg + i * 3;
		r *= (p[0] * f3[1][0] + p[1] * f3[1][1] + p[2] * f3[1][2])
			/ (p[0] * f3[0][0] + p[1] * f3[0][1] + p[2] * f3[0][2]);
	}
	for (; i < n; ++i) {
		const double *p = pdg + i * 3;
		r *= (p[0] * f3[2][0] + p[1] * f3[2][1] + p[2] * f3[2][2])
			/ (p[0] * f3[0][0] + p[1] * f3[0][1] + p[2] * f3[0][2]);
	}
	return r;
}

// Assembly:
testl %esi, %esi
jle 0x15bb1
movl %esi, %eax
movsd 0x18(%rcx), %xmm1
movsd 0x20(%rcx), %xmm2
movsd 0x28(%rcx), %xmm3
movhpd 0x10(%rcx), %xmm3       # xmm3 = xmm3[0],mem[0]
movhpd (%rcx), %xmm1           # xmm1 = xmm1[0],mem[0]
movhpd 0x8(%rcx), %xmm2        # xmm2 = xmm2[0],mem[0]
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
movsd 0x3519(%rip), %xmm0     # 0x19078
xorl %r8d, %r8d
movsd (%rdx,%r8), %xmm4
movsd 0x8(%rdx,%r8), %xmm5
movsd 0x10(%rdx,%r8), %xmm6
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
mulpd %xmm2, %xmm5
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm1, %xmm4
addpd %xmm5, %xmm4
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
mulpd %xmm3, %xmm6
addpd %xmm4, %xmm6
movapd %xmm6, %xmm4
unpckhpd %xmm6, %xmm4            # xmm4 = xmm4[1],xmm6[1]
divsd %xmm4, %xmm6
mulsd %xmm6, %xmm0
addq $0x18, %r8
cmpq %r8, %rax
jne 0x15b62
jmp 0x15bbb
movsd 0x34bf(%rip), %xmm0     # 0x19078
xorl %esi, %esi
cmpl %edi, %esi
jge 0x15c36
movl %esi, %esi
movsd 0x30(%rcx), %xmm1
movsd 0x38(%rcx), %xmm2
movsd 0x40(%rcx), %xmm3
movhpd 0x10(%rcx), %xmm3       # xmm3 = xmm3[0],mem[0]
movhpd (%rcx), %xmm1           # xmm1 = xmm1[0],mem[0]
movhpd 0x8(%rcx), %xmm2        # xmm2 = xmm2[0],mem[0]
movl %edi, %eax
leaq (%rsi,%rsi,2), %rcx
leaq (%rdx,%rcx,8), %rcx
addq $0x10, %rcx
subq %rsi, %rax
movsd -0x10(%rcx), %xmm4
movsd -0x8(%rcx), %xmm5
movsd (%rcx), %xmm6
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
mulpd %xmm2, %xmm5
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm1, %xmm4
addpd %xmm5, %xmm4
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
mulpd %xmm3, %xmm6
addpd %xmm4, %xmm6
movapd %xmm6, %xmm4
unpckhpd %xmm6, %xmm4            # xmm4 = xmm4[1],xmm6[1]
divsd %xmm4, %xmm6
mulsd %xmm6, %xmm0
addq $0x18, %rcx
decq %rax
jne 0x15bef
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/em.c
// Function: prob1
static double prob1(double f, void *data)
{
	minaux1_t *a = (minaux1_t*)data;
	double p = 1., l = 0., f3[3];
	int i;
//	printf("brent %lg\n", f);
	if (f < 0 || f > 1) return 1e300;
	f3[0] = (1.-f)*(1.-f); f3[1] = 2.*f*(1.-f); f3[2] = f*f;
	for (i = a->beg; i < a->end; ++i) {
		const double *pdg = a->pdg + i * 3;
		p *= pdg[0] * f3[0] + pdg[1] * f3[1] + pdg[2] * f3[2];
		if (p < 1e-200) l -= log(p), p = 1.;
	}
	return l - log(p);
}

// Assembly:
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm3, %xmm0
movsd 0x57f3(%rip), %xmm1     # 0x1b798
ja 0x160d6
ucomisd 0x30c5(%rip), %xmm3     # 0x19078
ja 0x160d6
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd 0x30ab(%rip), %xmm0     # 0x19078
movslq (%rdi), %r14
movl 0x4(%rdi), %eax
cmpl %eax, %r14d
jge 0x160b6
subsd %xmm3, %xmm0
movapd %xmm3, %xmm4
addsd %xmm3, %xmm4
mulsd %xmm0, %xmm4
movapd %xmm0, %xmm5
mulsd %xmm0, %xmm5
mulsd %xmm3, %xmm3
leaq (%r14,%r14,2), %rcx
leaq 0x10(,%rcx,8), %r15
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd 0x3063(%rip), %xmm1     # 0x19078
movsd 0x5783(%rip), %xmm6     # 0x1b7a0
movsd %xmm3, 0x18(%rsp)
movsd %xmm4, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
movq 0x8(%rbx), %rcx
movsd -0x8(%rcx,%r15), %xmm0
mulsd %xmm4, %xmm0
movsd -0x10(%rcx,%r15), %xmm2
mulsd %xmm5, %xmm2
addsd %xmm0, %xmm2
movsd (%rcx,%r15), %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
ucomisd %xmm0, %xmm6
jbe 0x1609d
callq 0x2210
movsd 0x572e(%rip), %xmm6     # 0x1b7a0
movsd 0x8(%rsp), %xmm5
movsd 0x10(%rsp), %xmm4
movsd 0x18(%rsp), %xmm3
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movl 0x4(%rbx), %eax
movsd 0x2fdb(%rip), %xmm0     # 0x19078
incq %r14
movslq %eax, %rcx
addq $0x18, %r15
movapd %xmm0, %xmm1
cmpq %rcx, %r14
jl 0x1602f
jmp 0x160bf
xorpd %xmm1, %xmm1
movsd %xmm1, (%rsp)
callq 0x2210
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/kfunc.c
// Function: kf_lgamma
double kf_lgamma(double z)
{
	double x = 0;
	x += 0.1659470187408462e-06 / (z+7);
	x += 0.9934937113930748e-05 / (z+6);
	x -= 0.1385710331296526     / (z+5);
	x += 12.50734324009056      / (z+4);
	x -= 176.6150291498386      / (z+3);
	x += 771.3234287757674      / (z+2);
	x -= 1259.139216722289      / (z+1);
	x += 676.5203681218835      / z;
	x += 0.9999999999995183;
	return log(x) - 5.58106146679532777 - z + (z-0.5) * log(z+6.5);
}

// Assembly:
subq $0x28, %rsp
movapd %xmm0, %xmm4
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd 0x56bc(%rip), %xmm0     # 0x1b7b0
addpd %xmm1, %xmm0
movapd 0x56c0(%rip), %xmm2     # 0x1b7c0
divpd %xmm0, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
xorpd %xmm0, %xmm0
addsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movapd 0x56b0(%rip), %xmm2     # 0x1b7d0
addpd %xmm1, %xmm2
movapd 0x56b4(%rip), %xmm3     # 0x1b7e0
divpd %xmm2, %xmm3
movapd %xmm3, %xmm2
unpckhpd %xmm3, %xmm2            # xmm2 = xmm2[1],xmm3[1]
subsd %xmm2, %xmm0
addsd %xmm3, %xmm0
addpd 0x56a8(%rip), %xmm1     # 0x1b7f0
movapd 0x56b0(%rip), %xmm2     # 0x1b800
divpd %xmm1, %xmm2
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
subsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movsd 0x2f0c(%rip), %xmm1     # 0x19078
movapd %xmm4, 0x10(%rsp)
addsd %xmm4, %xmm1
unpcklpd %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0]
movapd 0x568e(%rip), %xmm1     # 0x1b810
divpd %xmm4, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
subsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0x56b2(%rip), %xmm0     # 0x1b850
callq 0x2210
addsd 0x56ad(%rip), %xmm0     # 0x1b858
movapd 0x10(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x569d(%rip), %xmm0     # 0x1b860
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
addsd 0x5694(%rip), %xmm1     # 0x1b868
movapd %xmm1, %xmm0
callq 0x2210
mulsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/kfunc.c
// Function: kf_gammap
static double _kf_gammap(double s, double z)
{
	double sum, x;
	int k;
	for (k = 1, sum = x = 1.; k < 100; ++k) {
		sum += (x *= z / (s + k));
		if (x / sum < KF_GAMMA_EPS) break;
	}
	return exp(s * log(z) - z - kf_lgamma(s + 1.) + log(sum));
}

// Assembly:
movapd %xmm1, %xmm6
movapd %xmm0, %xmm5
movsd 0x2c8d(%rip), %xmm1     # 0x19078
movl $0x1, %eax
movsd 0x5518(%rip), %xmm0     # 0x1b910
movapd %xmm1, %xmm4
movapd %xmm1, %xmm2
xorps %xmm3, %xmm3
cvtsi2sd %eax, %xmm3
addsd %xmm5, %xmm3
movapd %xmm6, %xmm1
divsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm4
movapd %xmm1, %xmm2
divsd %xmm4, %xmm2
ucomisd %xmm2, %xmm0
ja 0x16433
leal 0x1(%rax), %ecx
cmpl $0x63, %eax
movl %ecx, %eax
jne 0x163fc
subq $0x18, %rsp
movapd %xmm6, %xmm0
movsd %xmm4, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
movsd %xmm6, (%rsp)
callq 0x2210
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
addsd 0x2c0b(%rip), %xmm1     # 0x19078
movapd %xmm1, %xmm0
callq 0x160dc
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2210
addsd (%rsp), %xmm0
addq $0x18, %rsp
jmp 0x2570
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/kfunc.c
// Function: kf_gammaq
static double _kf_gammaq(double s, double z)
{
	int j;
	double C, D, f;
	f = 1. + z - s; C = f; D = 0.;
	// Modified Lentz's algorithm for computing continued fraction
	// See Numerical Recipes in C, 2nd edition, section 5.2
	for (j = 1; j < 100; ++j) {
		double a = j * (s - j), b = (j<<1) + 1 + z - s, d;
		D = b + a * D;
		if (D < KF_TINY) D = KF_TINY;
		C = b + a / C;
		if (C < KF_TINY) C = KF_TINY;
		D = 1. / D;
		d = C * D;
		f *= d;
		if (fabs(d - 1.) < KF_GAMMA_EPS) break;
	}
	return exp(s * log(z) - z - kf_lgamma(s) - log(f));
}

// Assembly:
movapd %xmm1, %xmm11
movapd %xmm0, %xmm10
movsd 0x2bc9(%rip), %xmm0     # 0x19078
addsd %xmm1, %xmm0
subsd %xmm10, %xmm0
xorpd %xmm1, %xmm1
movl $0x1, %ecx
movl $0x3, %eax
movsd 0x544a(%rip), %xmm2     # 0x1b918
movsd 0x2ba2(%rip), %xmm3     # 0x19078
movsd 0x2bba(%rip), %xmm4     # 0x19098
movapd 0x529a(%rip), %xmm5     # 0x1b780
movsd 0x5422(%rip), %xmm6     # 0x1b910
movapd %xmm0, %xmm12
xorps %xmm7, %xmm7
cvtsi2sd %ecx, %xmm7
movapd %xmm10, %xmm8
subsd %xmm7, %xmm8
xorps %xmm9, %xmm9
cvtsi2sd %eax, %xmm9
mulsd %xmm7, %xmm8
addsd %xmm11, %xmm9
subsd %xmm10, %xmm9
mulsd %xmm8, %xmm1
addsd %xmm9, %xmm1
movapd %xmm2, %xmm7
maxsd %xmm1, %xmm7
movapd %xmm3, %xmm1
divsd %xmm7, %xmm1
divsd %xmm0, %xmm8
addsd %xmm9, %xmm8
movapd %xmm2, %xmm0
maxsd %xmm8, %xmm0
movapd %xmm0, %xmm7
mulsd %xmm1, %xmm7
mulsd %xmm7, %xmm12
addsd %xmm4, %xmm7
andpd %xmm5, %xmm7
ucomisd %xmm7, %xmm6
ja 0x16571
leal 0x1(%rcx), %edx
addl $0x2, %eax
cmpl $0x63, %ecx
movl %edx, %ecx
jne 0x164f3
subq $0x18, %rsp
movapd %xmm11, %xmm0
movsd %xmm10, 0x8(%rsp)
movsd %xmm11, (%rsp)
movsd %xmm12, 0x10(%rsp)
callq 0x2210
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movapd %xmm1, %xmm0
callq 0x160dc
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2210
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
jmp 0x2570
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/kfunc.c
// Function: kf_betai_aux
static double kf_betai_aux(double a, double b, double x)
{
	double C, D, f;
	int j;
	if (x == 0.) return 0.;
	if (x == 1.) return 1.;
	f = 1.; C = f; D = 0.;
	// Modified Lentz's algorithm for computing continued fraction
	for (j = 1; j < 200; ++j) {
		double aa, d;
		int m = j>>1;
		aa = (j&1)? -(a + m) * (a + b + m) * x / ((a + 2*m) * (a + 2*m + 1))
			: m * (b - m) * x / ((a + 2*m - 1) * (a + 2*m));
		D = 1. + aa * D;
		if (D < KF_TINY) D = KF_TINY;
		C = 1. + aa / C;
		if (C < KF_TINY) C = KF_TINY;
		D = 1. / D;
		d = C * D;
		f *= d;
		if (fabs(d - 1.) < KF_GAMMA_EPS) break;
	}
	return exp(kf_lgamma(a+b) - kf_lgamma(a) - kf_lgamma(b) + a * log(x) + b * log(1.-x)) / a / f;
}

// Assembly:
movapd %xmm0, %xmm12
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jne 0x16681
jp 0x16681
retq
movsd 0x29ef(%rip), %xmm0     # 0x19078
ucomisd %xmm0, %xmm2
jne 0x16691
jnp 0x16680
movapd %xmm12, %xmm0
addsd %xmm1, %xmm0
movl $0x1, %eax
xorpd %xmm7, %xmm7
movsd 0x29cc(%rip), %xmm13    # 0x19078
movsd 0x29e3(%rip), %xmm14    # 0x19098
movsd 0x525b(%rip), %xmm3     # 0x1b918
movapd 0x50bb(%rip), %xmm4     # 0x1b780
movsd 0x5243(%rip), %xmm5     # 0x1b910
movapd 0x516b(%rip), %xmm6     # 0x1b840
movapd %xmm13, %xmm8
movapd %xmm13, %xmm15
movl %eax, %ecx
shrl %ecx
xorps %xmm9, %xmm9
cvtsi2sd %ecx, %xmm9
testb $0x1, %al
jne 0x16708
movapd %xmm1, %xmm10
subsd %xmm9, %xmm10
mulsd %xmm10, %xmm9
movl %eax, %ecx
movapd %xmm14, %xmm10
jmp 0x1672e
movapd %xmm0, %xmm10
addsd %xmm9, %xmm10
addsd %xmm12, %xmm9
xorpd %xmm6, %xmm9
mulsd %xmm10, %xmm9
movl %eax, %ecx
andl $0xfe, %ecx
movapd %xmm13, %xmm10
mulsd %xmm2, %xmm9
xorps %xmm11, %xmm11
cvtsi2sd %ecx, %xmm11
addsd %xmm12, %xmm11
addsd %xmm11, %xmm10
mulsd %xmm11, %xmm10
divsd %xmm10, %xmm9
mulsd %xmm9, %xmm7
addsd %xmm13, %xmm7
movapd %xmm3, %xmm10
maxsd %xmm7, %xmm10
divsd %xmm8, %xmm9
addsd %xmm13, %xmm9
movapd %xmm3, %xmm8
maxsd %xmm9, %xmm8
movapd %xmm13, %xmm7
divsd %xmm10, %xmm7
movapd %xmm8, %xmm9
mulsd %xmm7, %xmm9
mulsd %xmm9, %xmm15
addsd %xmm14, %xmm9
andpd %xmm4, %xmm9
ucomisd %xmm9, %xmm5
ja 0x167b2
leal 0x1(%rax), %ecx
cmpl $0xc7, %eax
movl %ecx, %eax
jne 0x166df
subq $0x28, %rsp
movsd %xmm12, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm15, 0x20(%rsp)
callq 0x160dc
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x160dc
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x160dc
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2210
mulsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x2849(%rip), %xmm0     # 0x19078
subsd 0x10(%rsp), %xmm0
callq 0x2210
mulsd 0x18(%rsp), %xmm0
addsd (%rsp), %xmm0
callq 0x2570
divsd 0x8(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/kmin.c
// Function: _kmin_hj_aux
static double __kmin_hj_aux(kmin_f func, int n, double *x1, void *data, double fx1, double *dx, int *n_calls)
{
	int k, j = *n_calls;
	double ftmp;
	for (k = 0; k != n; ++k) {
		x1[k] += dx[k];
		ftmp = func(n, x1, data); ++j;
		if (ftmp < fx1) fx1 = ftmp;
		else { /* search the opposite direction */
			dx[k] = 0.0 - dx[k];
			x1[k] += dx[k] + dx[k];
			ftmp = func(n, x1, data); ++j;
			if (ftmp < fx1) fx1 = ftmp;
			else x1[k] -= dx[k]; /* back to the original x[k] */
		}
	}
	*n_calls = j;
	return fx1; /* here: fx1=f(n,x1) */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %r9, 0x18(%rsp)
movl (%r9), %ebx
movl %esi, 0x4(%rsp)
testl %esi, %esi
je 0x16bed
movq %r8, %r14
movq %rdx, %r12
movq %rdi, %rbp
movl 0x4(%rsp), %edx
movq %rdx, 0x20(%rsp)
xorl %r15d, %r15d
movq %rcx, 0x10(%rsp)
movsd (%r14,%r15,8), %xmm0
addsd (%r12,%r15,8), %xmm0
movsd %xmm0, (%r12,%r15,8)
movl 0x4(%rsp), %edi
movq %r12, %rsi
movq %rcx, %rdx
movq %rcx, %r13
callq *%rbp
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x16b7f
incl %ebx
movsd %xmm0, 0x8(%rsp)
movq %r13, %rcx
jmp 0x16bdf
xorpd %xmm0, %xmm0
subsd (%r14,%r15,8), %xmm0
movsd %xmm0, (%r14,%r15,8)
addsd %xmm0, %xmm0
addsd (%r12,%r15,8), %xmm0
movsd %xmm0, (%r12,%r15,8)
movl 0x4(%rsp), %edi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %r13
callq *%rbp
addl $0x2, %ebx
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x16bc5
movsd %xmm0, 0x8(%rsp)
jmp 0x16bd7
movsd (%r12,%r15,8), %xmm0
subsd (%r14,%r15,8), %xmm0
movsd %xmm0, (%r12,%r15,8)
movq 0x10(%rsp), %rcx
movq %r13, %rbp
incq %r15
cmpq %r15, 0x20(%rsp)
jne 0x16b45
movq 0x18(%rsp), %rax
movl %ebx, (%rax)
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/index.c
// Function: bcf_idx_destroy
void bcf_idx_destroy(bcf_idx_t *idx)
{
	int i;
	if (idx == 0) return;
	for (i = 0; i < idx->n; ++i) free(idx->index2[i].offset);
	free(idx->index2);
	free(idx);
}

// Assembly:
testq %rdi, %rdi
je 0x17619
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x17603
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2060
incq %r15
movslq (%rbx), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x175e7
movq 0x8(%rbx), %rdi
callq 0x2060
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/index.c
// Function: bcf_idx_save
void bcf_idx_save(const bcf_idx_t *idx, BGZF *fp)
{
	int32_t i, ti_is_be;
	ti_is_be = bam_is_big_endian();
	bgzf_write(fp, "BCI\4", 4);
	if (ti_is_be) {
		uint32_t x = idx->n;
		bgzf_write(fp, bam_swap_endian_4p(&x), 4);
	} else bgzf_write(fp, &idx->n, 4);
	for (i = 0; i < idx->n; ++i) {
		bcf_lidx_t *index2 = idx->index2 + i;
		// write linear index (index2)
		if (ti_is_be) {
			int x = index2->n;
			bgzf_write(fp, bam_swap_endian_4p(&x), 4);
		} else bgzf_write(fp, &index2->n, 4);
		if (ti_is_be) { // big endian
			int x;
			for (x = 0; (int)x < index2->n; ++x)
				bam_swap_endian_8p(&index2->offset[x]);
			bgzf_write(fp, index2->offset, 8 * index2->n);
			for (x = 0; (int)x < index2->n; ++x)
				bam_swap_endian_8p(&index2->offset[x]);
		} else bgzf_write(fp, index2->offset, 8 * index2->n);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4342(%rip), %rsi      # 0x1b972
movl $0x4, %edx
movq %rbx, %rdi
callq 0x88ec
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88ec
cmpl $0x0, (%r14)
jle 0x17693
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %r13
leaq (%r15,%r13), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x88ec
movq 0x8(%r13,%r15), %rsi
movslq (%r13,%r15), %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
callq 0x88ec
incq %r12
movslq (%r14), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x17659
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/index.c
// Function: bcf_idx_load_local
bcf_idx_t *bcf_idx_load_local(const char *fnidx)
{
	BGZF *fp;
	fp = bgzf_open(fnidx, "r");
	if (fp) {
		bcf_idx_t *idx = bcf_idx_load_core(fp);
		bgzf_close(fp);
		return idx;
	} else return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x345d(%rip), %rsi      # 0x1ab0c
callq 0x79f0
testq %rax, %rax
je 0x1777f
movq %rax, %rbx
leaq 0x4(%rsp), %r14
movl $0x4, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x838d
cmpl $0x4494342, (%r14)      # imm = 0x4494342
jne 0x17794
movl $0x1, %edi
movl $0x10, %esi
callq 0x2260
movq %rax, %r14
movl $0x4, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x838d
movslq (%r14), %r15
movl $0x10, %esi
movq %r15, %rdi
callq 0x2260
movq %rax, 0x8(%r14)
testq %r15, %r15
jle 0x17775
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rbp
leaq (%r12,%rbp), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x838d
movslq (%rbp,%r12), %r15
movl %r15d, 0x4(%rbp,%r12)
movl $0x8, %esi
movq %r15, %rdi
callq 0x2260
movq %rax, 0x8(%rbp,%r12)
shlq $0x3, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x838d
incq %r13
movslq (%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x17723
movq %rbx, %rdi
callq 0x89f9
jmp 0x17782
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b60
xorl %r14d, %r14d
jmp 0x17775
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/index.c
// Function: bcf_idx_load
bcf_idx_t *bcf_idx_load(const char *fn)
{
	bcf_idx_t *idx;
    char *fname = get_local_version(fn);
	if (fname == 0) return 0;
	idx = bcf_idx_load_local(fname);
    free(fname);
	return idx;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
callq 0x2180
leaq 0x5(%rax), %rdi
movl $0x1, %esi
callq 0x2260
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x20a0
movq %rbx, %rdi
callq 0x2180
movl $0x6963622e, (%rbx,%rax) # imm = 0x6963622E
movb $0x0, 0x4(%rbx,%rax)
leaq 0x3760(%rip), %rsi      # 0x1af47
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x1782c
leaq 0x3793(%rip), %rsi      # 0x1af92
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x1782c
movq %rbx, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x17871
movq %r14, %rbx
xorl %r14d, %r14d
jmp 0x17869
movq %rbx, %rdi
callq 0x2180
cltq
addq %rbx, %rax
decq %rax
movq %rax, %rdi
cmpq %rbx, %rax
jb 0x1784d
leaq -0x1(%rdi), %rax
cmpb $0x2f, (%rdi)
jne 0x1783c
incq %rdi
callq 0x2510
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2190
testl %eax, %eax
jne 0x1789b
movq %rbx, %rdi
callq 0x2060
testq %r14, %r14
je 0x1788e
movq %r14, %rdi
callq 0x1769d
movq %rax, %rbx
movq %r14, %rdi
callq 0x2060
movq %rbx, %rax
jmp 0x17890
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x2b85
jmp 0x17813
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/index.c
// Function: bcf_idx_build2
int bcf_idx_build2(const char *fn, const char *_fnidx)
{
	char *fnidx;
	BGZF *fpidx;
	bcf_t *bp;
	bcf_idx_t *idx;
	bcf_hdr_t *h;
	if ((bp = bcf_open(fn, "r")) == 0) {
		fprintf(stderr, "[bcf_idx_build2] fail to open the BAM file.\n");
		return -1;
	}
	h = bcf_hdr_read(bp);
	idx = bcf_idx_core(bp, h);
	bcf_close(bp);
	if (_fnidx == 0) {
		fnidx = (char*)calloc(strlen(fn) + 5, 1);
		strcpy(fnidx, fn); strcat(fnidx, ".bci");
	} else fnidx = strdup(_fnidx);
	fpidx = bgzf_open(fnidx, "w");
	if (fpidx == 0) {
		fprintf(stderr, "[bcf_idx_build2] fail to create the index file.\n");
		free(fnidx);
        bcf_idx_destroy(idx);
		return -1;
	}
	bcf_idx_save(idx, fpidx);
	bcf_idx_destroy(idx);
	bgzf_close(fpidx);
	free(fnidx);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x324f(%rip), %rsi      # 0x1ab0c
callq 0xb4e8
testq %rax, %rax
je 0x17980
movq %rax, %r12
movq %rax, %rdi
callq 0xb658
movq %r12, %rdi
movq %rax, %rsi
callq 0x173dc
movq %rax, %rbx
movq %r12, %rdi
callq 0xb56e
testq %r14, %r14
je 0x178fe
movq %r14, %rdi
callq 0x2510
movq %rax, %r14
jmp 0x17938
movq %r15, %rdi
callq 0x2180
leaq 0x5(%rax), %rdi
movl $0x1, %esi
callq 0x2260
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x20a0
movq %r14, %rdi
callq 0x2180
movl $0x6963622e, (%r14,%rax) # imm = 0x6963622E
movb $0x0, 0x4(%r14,%rax)
leaq 0x1963(%rip), %rsi      # 0x192a2
movq %r14, %rdi
callq 0x79f0
testq %rax, %rax
je 0x17987
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1761a
movq %rbx, %rdi
callq 0x175cc
movq %r15, %rdi
callq 0x89f9
movq %r14, %rdi
callq 0x2060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2d1f
jmp 0x17992
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ce2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x17974
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/index.c
// Function: bcf_parse_region
int bcf_parse_region(void *str2id, const char *str, int *tid, int *begin, int *end)
{
	char *s, *p;
	int i, l, k;
	l = strlen(str);
	p = s = (char*)malloc(l+1);
	/* squeeze out "," */
	for (i = k = 0; i != l; ++i)
		if (str[i] != ',' && !isspace(str[i])) s[k++] = str[i];
	s[k] = 0;
	for (i = 0; i != k; ++i) if (s[i] == ':') break;
	s[i] = 0;
	if ((*tid = bcf_str2id(str2id, s)) < 0) {
		free(s);
		return -1;
	}
	if (i == k) { /* dump the whole sequence */
		*begin = 0; *end = 1<<29; free(s);
		return 0;
	}
	for (p = s + i + 1; i != k; ++i) if (s[i] == '-') break;
	*begin = atoi(p);
	if (i < k) {
		p = s + i + 1;
		*end = atoi(p);
	} else *end = 1<<29;
	if (*begin > 0) --*begin;
	free(s);
	if (*begin > *end) return -1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, 0x8(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %rbp
movq %rdi, 0x18(%rsp)
movq %rsi, %rdi
callq 0x2180
movq %rax, %rbx
incl %eax
movslq %eax, %rdi
callq 0x2360
movq %rax, %r14
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
andq %rbx, %r15
je 0x17a48
movq %r12, 0x10(%rsp)
xorl %r12d, %r12d
xorl %ebx, %ebx
movsbq (%rbp,%r12), %r13
cmpq $0x2c, %r13
je 0x17a15
callq 0x2580
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
jne 0x17a15
movslq %ebx, %rax
incl %ebx
movb %r13b, (%r14,%rax)
incq %r12
cmpq %r12, %r15
jne 0x179f0
movslq %ebx, %rax
movb $0x0, (%r14,%rax)
movb $0x1, %bpl
testl %eax, %eax
je 0x17a55
movl %ebx, %ecx
xorl %eax, %eax
movq 0x10(%rsp), %r12
cmpb $0x3a, (%r14,%rax)
je 0x17a60
incq %rax
cmpq %rax, %rcx
jne 0x17a35
movl %ecx, %eax
jmp 0x17a62
movb $0x0, (%r14)
movb $0x1, %bpl
xorl %ebx, %ebx
xorl %eax, %eax
jmp 0x17a62
xorl %ebx, %ebx
xorl %eax, %eax
movq 0x10(%rsp), %r12
jmp 0x17a62
xorl %ebp, %ebp
movl %eax, %r15d
movb $0x0, (%r14,%r15)
movq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xe784
movq 0x20(%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
js 0x17aa6
testb %bpl, %bpl
je 0x17ab5
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movl $0x20000000, (%r12)     # imm = 0x20000000
movq %r14, %rdi
callq 0x2060
xorl %eax, %eax
jmp 0x17b09
movq %r14, %rdi
callq 0x2060
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x17b09
leaq (%r14,%r15), %rdi
incq %rdi
cmpl %ebx, %r15d
je 0x17ad2
movl %ebx, %eax
cmpb $0x2d, (%r14,%r15)
je 0x17b18
incq %r15
cmpq %r15, %rax
jne 0x17ac3
callq 0x2470
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movq %rcx, %rax
movl $0x20000000, %ebp       # imm = 0x20000000
movl %ebp, (%r12)
movl (%rax), %ebx
testl %ebx, %ebx
jle 0x17af8
decl %ebx
movl %ebx, (%rax)
movl (%r12), %ebp
movq %r14, %rdi
callq 0x2060
xorl %eax, %eax
cmpl %ebp, %ebx
setg %al
negl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2470
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movq %rcx, %rax
movl $0x20000000, %ebp       # imm = 0x20000000
cmpl %r15d, %ebx
jle 0x17ae6
movl %r15d, %eax
leaq (%r14,%rax), %rdi
incq %rdi
callq 0x2470
movl %eax, %ebp
movq 0x8(%rsp), %rax
jmp 0x17ae6
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/index.c
// Function: bcf_idx_query
uint64_t bcf_idx_query(const bcf_idx_t *idx, int tid, int beg)
{
	uint64_t min_off, *offset;
	int i;
	if (beg < 0) beg = 0;
	offset = idx->index2[tid].offset;
	for (i = beg>>TAD_LIDX_SHIFT; i < idx->index2[tid].n && offset[i] == 0; ++i);
	min_off = (i == idx->index2[tid].n)? offset[idx->index2[tid].n-1] : offset[i];
	return min_off;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovgl %edx, %eax
movq 0x8(%rdi), %rdx
movslq %esi, %rsi
shlq $0x4, %rsi
movq 0x8(%rdx,%rsi), %rcx
shrl $0xd, %eax
movslq (%rdx,%rsi), %rdx
cmpl %edx, %eax
jge 0x17b83
movl %edx, %esi
leal (%rsi,%rax), %edi
subl %eax, %edi
cmpq $0x0, (%rcx,%rax,8)
jne 0x17b83
incq %rax
cmpq %rax, %rdi
jne 0x17b72
movl %esi, %eax
cmpl %edx, %eax
leaq -0x8(%rcx,%rdx,8), %rdx
movl %eax, %eax
leaq (%rcx,%rax,8), %rax
cmoveq %rdx, %rax
movq (%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/index.c
// Function: bcf_main_index
int bcf_main_index(int argc, char *argv[])
{
	if (argc == 1) {
		fprintf(stderr, "Usage: bcftools index <in.bcf>\n");
		return 1;
	}
	bcf_idx_build(argv[1]);
	return 0;
}

// Assembly:
pushq %rbx
cmpl $0x1, %edi
je 0x17baf
movq 0x8(%rsi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x178a8
movl %ebx, %eax
popq %rbx
retq
callq 0x2d3b
movl $0x1, %ebx
jmp 0x17bab
nop
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/mut.c
// Function: bcf_pair_call
int bcf_pair_call(const bcf1_t *b)
{
	int i, j, k;
	const bcf_ginfo_t *PL;
	if (b->n_smpl != 2) return -1; // not a pair
	for (i = 0; i < b->n_gi; ++i)
		if (b->gi[i].fmt == bcf_str2int("PL", 2)) break;
	if (i == b->n_gi) return -1; // no PL
	PL = b->gi + i;
	for (j = 0; j < 2; ++j) // check if ref hom is the most probable in all members
		if (((uint8_t*)PL->data)[j * PL->len] != 0) break;
	if (j < 2) { // we need to go through the complex procedure
		uint8_t *g[2];
		int minc = 1<<30, minf = 0;
		g[0] = PL->data;
		g[1] = (uint8_t*)PL->data + PL->len;
		for (j = 0; j < PL->len; ++j) // compute LK with constraint
			minc = minc < g[0][j] + g[1][j]? minc : g[0][j] + g[1][j];
		for (j = 0; j < 2; ++j) { // compute LK without constraint
			int min = 1<<30;
			for (k = 0; k < PL->len; ++k)
				min = min < g[j][k]? min : g[j][k];
			minf += min;
		}
		return minc - minf;
	} else return 0;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, 0x5c(%rdi)
jne 0x184c4
pushq %rbx
movslq 0x48(%rdi), %rcx
testq %rcx, %rcx
jle 0x18407
movq 0x50(%rdi), %rsi
xorl %edx, %edx
cmpl $0x504c, (%rsi)         # imm = 0x504C
je 0x18409
incq %rdx
addq $0x10, %rsi
cmpq %rdx, %rcx
jne 0x183ee
jmp 0x184c3
xorl %edx, %edx
cmpl %ecx, %edx
je 0x184c3
movq 0x50(%rdi), %rax
movl %edx, %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rdx
movslq 0x4(%rax,%rcx), %rcx
cmpb $0x0, (%rdx)
jne 0x18434
cmpb $0x0, (%rdx,%rcx)
je 0x184c5
movq %rdx, -0x10(%rsp)
leaq (%rdx,%rcx), %rsi
movq %rsi, -0x8(%rsp)
testl %ecx, %ecx
jle 0x1846e
movl $0x40000000, %r8d       # imm = 0x40000000
xorl %edi, %edi
movzbl (%rdx,%rdi), %r9d
movzbl (%rsi,%rdi), %eax
addl %r9d, %eax
cmpl %eax, %r8d
cmovll %r8d, %eax
incq %rdi
movl %eax, %r8d
cmpq %rdi, %rcx
jne 0x1844e
jmp 0x18473
movl $0x40000000, %eax       # imm = 0x40000000
movl %ecx, %esi
xorl %edx, %edx
leaq -0x10(%rsp), %r9
movb $0x1, %dil
leaq -0x8(%rsp), %r8
testl %ecx, %ecx
jle 0x184aa
movq (%r9), %r10
movl $0x40000000, %r9d       # imm = 0x40000000
xorl %r11d, %r11d
movzbl (%r10,%r11), %ebx
cmpl %ebx, %r9d
cmovgel %ebx, %r9d
incq %r11
cmpq %r11, %rsi
jne 0x18494
jmp 0x184b0
movl $0x40000000, %r9d       # imm = 0x40000000
addl %r9d, %edx
movq %r8, %r9
testb $0x1, %dil
movl $0x0, %edi
jne 0x18484
subl %edx, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x184c3
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/mut.c
// Function: bcf_min_diff
int bcf_min_diff(const bcf1_t *b)
{
	int i, min = 1<<30;
	const bcf_ginfo_t *PL;
	for (i = 0; i < b->n_gi; ++i)
		if (b->gi[i].fmt == bcf_str2int("PL", 2)) break;
	if (i == b->n_gi) return -1; // no PL
	PL = b->gi + i;
	for (i = 0; i < b->n_smpl; ++i) {
		int m1, m2, j;
		const uint8_t *p = (uint8_t*)PL->data;
		m1 = m2 = 1<<30;
		for (j = 0; j < PL->len; ++j) {
			if ((int)p[j] < m1) m2 = m1, m1 = p[j];
			else if ((int)p[j] < m2) m2 = p[j];
		}
		min = min < m2 - m1? min : m2 - m1;
	}
	return min;
}

// Assembly:
movslq 0x48(%rdi), %rcx
testq %rcx, %rcx
jle 0x184f2
movq 0x50(%rdi), %rax
xorl %edx, %edx
cmpl $0x504c, (%rax)         # imm = 0x504C
je 0x184f4
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x184d8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
xorl %edx, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %edx
je 0x18569
movl 0x5c(%rdi), %ecx
testl %ecx, %ecx
jle 0x1856a
movq 0x50(%rdi), %rax
movl %edx, %esi
shlq $0x4, %rsi
movq 0x8(%rax,%rsi), %rdx
movl 0x4(%rax,%rsi), %esi
movl $0x40000000, %eax       # imm = 0x40000000
xorl %edi, %edi
movl $0x0, %r8d
testl %esi, %esi
jle 0x1855c
movl $0x40000000, %r8d       # imm = 0x40000000
xorl %r9d, %r9d
movl $0x40000000, %r10d      # imm = 0x40000000
movl %r10d, %r11d
movzbl (%rdx,%r9), %r10d
cmpl %r10d, %r8d
cmovgel %r10d, %r8d
cmpl %r10d, %r11d
cmovll %r11d, %r10d
cmovgl %r11d, %r8d
incq %r9
cmpq %r9, %rsi
jne 0x18537
subl %r10d, %r8d
cmpl %r8d, %eax
cmovgel %r8d, %eax
incl %edi
cmpl %ecx, %edi
jne 0x1851e
retq
movl $0x40000000, %eax       # imm = 0x40000000
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/object.c
// Function: createObject
robj *createObject(int type, void *ptr) {
    robj *o = zmalloc(sizeof(*o));
    o->type = type;
    o->encoding = OBJ_ENCODING_RAW;
    o->ptr = ptr;
    o->refcount = 1;

    /* Set the LRU to the current lruclock (minutes resolution). */
    o->lru = LRU_CLOCK();

#ifdef AOF_NO_COW
    o->aof_version = server.aof_no_cow.version;
    o->shared = 0;
#endif

    return o;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x10, %edi
callq 0x3b4e9
andl $0xf, %ebp
movb %bpl, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc2fde(%rip), %rcx     # 0x106858
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl %ebp, %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/object.c
// Function: createEmbeddedStringObject
robj *createEmbeddedStringObject(const char *ptr, size_t len) {
    robj *o = zmalloc(sizeof(robj)+sizeof(struct sdshdr8)+len+1);
    struct sdshdr8 *sh = (void*)(o+1);

    o->type = OBJ_STRING;
    o->encoding = OBJ_ENCODING_EMBSTR;
    o->ptr = sh+1;
    o->refcount = 1;
    o->lru = LRU_CLOCK();

#ifdef AOF_NO_COW
    o->aof_version = server.aof_no_cow.version;
    o->shared = 0;
#endif

    sh->len = len;
    sh->alloc = len;
    sh->flags = SDS_TYPE_8;
    if (ptr) {
        memcpy(sh->buf,ptr,len);
        sh->buf[len] = '\0';
    } else {
        memset(sh->buf,0,len+1);
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x14(%rsi), %rdi
callq 0x3b4e9
movq %rax, %r14
movb $-0x80, (%rax)
leaq 0x13(%rax), %r12
movq %r12, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc2f68(%rip), %rax     # 0x106858
movl 0x48(%rax), %eax
shll $0x8, %eax
orl $0x80, %eax
movl %eax, (%r14)
movb %bl, 0x10(%r14)
movb %bl, 0x11(%r14)
movb $0x1, 0x12(%r14)
testq %r15, %r15
je 0x43925
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x26c60
movb $0x0, (%r12,%rbx)
jmp 0x43935
incq %rbx
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x26110
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/aof.c
// Function: stopAppendOnly
void stopAppendOnly(void) {
    serverAssert(server.aof_state != AOF_OFF);
    flushAppendOnlyFile(1);
    aof_fsync(server.aof_fd);
    close(server.aof_fd);

    server.aof_fd = -1;
    server.aof_selected_db = -1;
    server.aof_state = AOF_OFF;
    /* rewrite operation in progress? kill it, wait child exit */
    if (server.aof_child_pid != -1) {
        int statloc;

        serverLog(LL_NOTICE,"Killing running AOF rewrite child: %ld",
            (long) server.aof_child_pid);
        if (kill(server.aof_child_pid,SIGUSR1) != -1) {
#ifndef AOF_NO_COW
            while(wait3(&statloc,0,NULL) != server.aof_child_pid);
#else
            while(wait3(&statloc, __WALL, NULL) != server.aof_child_pid);
#endif
        }
        /* reset the buffer accumulating changes while the child saves */
        aofRewriteBufferReset();
        aofRemoveTempFile(server.aof_child_pid);
        server.aof_child_pid = -1;
        server.aof_rewrite_time_start = -1;
        /* close pipes used for IPC between the two processes. */
        aofClosePipes();
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
leaq 0xa66ec(%rip), %r14     # 0x106858
cmpl $0x0, 0x658(%r14)
je 0x6025b
movl $0x1, %edi
callq 0x6027d
movl 0x6a0(%r14), %edi
callq 0x26580
movl 0x6a0(%r14), %edi
callq 0x26180
movq $-0x1, 0x6a0(%r14)
movl $0x0, 0x658(%r14)
movslq 0x68c(%r14), %rdx
cmpq $-0x1, %rdx
je 0x60250
leaq 0x67d87(%rip), %rsi     # 0xc7f51
movl $0x2, %edi
xorl %eax, %eax
callq 0x33005
movl 0x68c(%r14), %edi
movl $0xa, %esi
callq 0x26670
cmpl $-0x1, %eax
je 0x60206
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x26880
cmpl 0x68c(%r14), %eax
jne 0x601f1
callq 0x5fe1c
movl 0x68c(%r14), %ecx
leaq 0x6874f(%rip), %rdx     # 0xc8968
leaq 0x10(%rsp), %rbx
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
xorl %eax, %eax
callq 0x26120
movq %rbx, %rdi
callq 0x263c0
movl $0xffffffff, 0x68c(%r14) # imm = 0xFFFFFFFF
movq $-0x1, 0x6c0(%r14)
callq 0x60837
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
leaq 0x67ccd(%rip), %rdi     # 0xc7f2f
leaq 0x67ce2(%rip), %rsi     # 0xc7f4b
movl $0xd6, %edx
callq 0x64900
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/cluster.c
// Function: representClusterNodeFlags
sds representClusterNodeFlags(sds ci, uint16_t flags) {
    if (flags == 0) {
        ci = sdscat(ci,"noflags,");
    } else {
        int i, size = sizeof(redisNodeFlagsTable)/sizeof(struct redisNodeFlags);
        for (i = 0; i < size; i++) {
            struct redisNodeFlags *nodeflag = redisNodeFlagsTable + i;
            if (flags & nodeflag->flag) ci = sdscat(ci, nodeflag->name);
        }
    }
    sdsIncrLen(ci,-1); /* Remove trailing comma. */
    return ci;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x6a3bd
movl %esi, %ebp
movl $0x8, %r14d
leaq 0x947d6(%rip), %r15     # 0xfeb70
testw %bp, -0x8(%r14,%r15)
je 0x6a3b1
movq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x39db4
movq %rax, %rbx
addq $0x10, %r14
cmpq $0x78, %r14
jne 0x6a39a
jmp 0x6a3cf
leaq 0x61288(%rip), %rsi     # 0xcb64c
movq %rbx, %rdi
callq 0x39db4
movq %rax, %rbx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x39a38
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/cluster.c
// Function: clusterDelNodeSlots
int clusterDelNodeSlots(clusterNode *node) {
    int deleted = 0, j;

    for (j = 0; j < CLUSTER_SLOTS; j++) {
        if (clusterNodeGetSlotBit(node,j)) clusterDelSlot(j);
        deleted++;
    }
    return deleted;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, %eax
shrl $0x3, %eax
movzbl 0x40(%rbx,%rax), %eax
movl %ebp, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jae 0x6b57c
movl %ebp, %edi
callq 0x6936b
incl %ebp
cmpl $0x4000, %ebp           # imm = 0x4000
jne 0x6b561
movl $0x4000, %eax           # imm = 0x4000
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/src/cluster.c
// Function: clusterRedirectBlockedClientIfNeeded
int clusterRedirectBlockedClientIfNeeded(client *c) {
    if (c->flags & CLIENT_BLOCKED && c->btype == BLOCKED_LIST) {
        dictEntry *de;
        dictIterator *di;

        /* If the cluster is down, unblock the client with the right error. */
        if (server.cluster->state == CLUSTER_FAIL) {
            clusterRedirectClient(c,NULL,0,CLUSTER_REDIR_DOWN_STATE);
            return 1;
        }

        di = dictGetIterator(c->bpop.keys);
        while((de = dictNext(di)) != NULL) {
            robj *key = dictGetKey(de);
            int slot = keyHashSlot((char*)key->ptr, sdslen(key->ptr));
            clusterNode *node = server.cluster->slots[slot];

            /* We send an error and unblock the client if:
             * 1) The slot is unassigned, emitting a cluster down error.
             * 2) The slot is not handled by this node, nor being imported. */
            if (node != myself &&
                server.cluster->importing_slots_from[slot] == NULL)
            {
                if (node == NULL) {
                    clusterRedirectClient(c,NULL,0,
                        CLUSTER_REDIR_DOWN_UNBOUND);
                } else {
                    clusterRedirectClient(c,node,slot,
                        CLUSTER_REDIR_MOVED);
                }
                return 1;
            }
        }
        dictReleaseIterator(di);
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
testb $0x10, 0x98(%rdi)
je 0x70015
movq %rdi, %rbx
cmpl $0x1, 0x168(%rdi)
jne 0x70015
leaq 0x9690f(%rip), %r15     # 0x106858
movq 0x9a0(%r15), %rax
cmpl $0x1, 0x10(%rax)
jne 0x6ff77
leaq 0x5c386(%rip), %rdi     # 0xcc2e3
callq 0x394c8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3fc9e
movl $0x1, %ebp
jmp 0x70015
movq 0x178(%rbx), %rdi
callq 0x32213
movq %rax, %r14
movq %rax, %rdi
callq 0x3226d
testq %rax, %rax
je 0x7000d
leaq 0x5a61e(%rip), %r12     # 0xca5b8
movq (%rax), %rax
movq 0x8(%rax), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x6ffd4
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x6ffd6
movq -0x11(%rdi), %rsi
jmp 0x6ffd6
movzwl -0x5(%rdi), %esi
jmp 0x6ffd6
movl -0x9(%rdi), %esi
jmp 0x6ffd6
movzbl -0x3(%rdi), %esi
jmp 0x6ffd6
xorl %esi, %esi
callq 0x696f9
movq 0x9a0(%r15), %rcx
movl %eax, %edx
movq 0x40028(%rcx,%rdx,8), %rsi
cmpq 0xab1dd(%rip), %rsi     # 0x11b1d0
je 0x70000
cmpq $0x0, 0x20028(%rcx,%rdx,8)
je 0x70020
movq %r14, %rdi
callq 0x3226d
testq %rax, %rax
jne 0x6ff9a
movq %r14, %rdi
callq 0x32335
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testq %rsi, %rsi
je 0x70037
movq %rbx, %rdi
movl $0x4, %ecx
callq 0x6fe48
jmp 0x6ff6d
leaq 0x5c2c8(%rip), %rdi     # 0xcc306
jmp 0x6ff5d
nop
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/hachageMain.c
// Function: main
int main()
{
    // Q4.2
    float k;
    for (int i = 0; i < 11; i++)
    {
        for (int j = 0; j < 11; j++)
        {
            k = fonctionCle(i, j);
            printf("x = %d, y = %d, k = %.2f\n", i, j, k);
        }
    }

    // lecture et creation d'une instance de Chaines et de Reseau
    FILE* f = NULL;
    f = fopen("00014_burma.cha", "r");
    Chaines *c = lectureChaines(f);
    fclose(f);
    Reseau *R = reconstitueReseauHachage(c, 5);
    FILE* f2 = NULL;

    // // l'enregistrement dans un fichier
    f2 = fopen("resHachage.txt", "w");
    ecrireReseau(R, f2);
    fclose(f2);

    // affichage
    afficheReseauSVG(R, "resoHachage");

    // liberation de memoire
    liberer_chaines(c);
    liberation_reseau(R);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorl %ebx, %ebx
xorpd %xmm0, %xmm0
leaq 0xd99(%rip), %r14       # 0x33fc
xorps %xmm2, %xmm2
xorl %ebp, %ebp
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movaps %xmm2, %xmm1
callq 0x121c
fstps 0x4(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movb $0x1, %al
callq 0x1080
movsd 0x10(%rsp), %xmm2
movsd 0x95d(%rip), %xmm1      # 0x3008
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm2
incl %ebp
cmpl $0xb, %ebp
jne 0x266e
addsd %xmm1, %xmm0
incl %ebx
cmpl $0xb, %ebx
jne 0x2663
leaq 0xd48(%rip), %rdi       # 0x3416
leaq 0xd51(%rip), %rsi       # 0x3426
callq 0x10e0
movq %rax, %r14
movq %rax, %rdi
callq 0x2088
movq %rax, %rbx
movq %r14, %rdi
callq 0x1060
movq %rbx, %rdi
movl $0x5, %esi
callq 0x14bb
movq %rax, %r14
leaq 0xd21(%rip), %rdi       # 0x3428
leaq 0xb48(%rip), %rsi       # 0x3256
callq 0x10e0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x1a12
movq %r15, %rdi
callq 0x1060
leaq 0xd07(%rip), %rsi       # 0x3437
movq %r14, %rdi
callq 0x1c04
movq %rbx, %rdi
callq 0x2633
movq %r14, %rdi
callq 0x1e66
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johnvtan[P]ccccc/alloc.c
// Function: alloc_homes
void alloc_homes(program_t *prog) {
    pair_t *pair;
    map_for_each(prog->fn_defs, pair) {
        fn_def_t *curr_fn = pair->value;
        debug("allocating for function %s\n", string_get(curr_fn->name));
        curr_fn->sp_offset = alloc_scoped_env(curr_fn->env, 0);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rdi)
addq $0x10, %rdi
leaq 0x8(%rsp), %rsi
callq 0x309c
testb %al, %al
je 0x12c0
leaq 0x8(%rsp), %r14
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
movq 0x20(%r15), %rdi
xorl %esi, %esi
callq 0x12ca
cltq
movq %rax, 0x28(%r15)
movq (%rbx), %rax
movq (%rax), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x309c
testb %al, %al
jne 0x1290
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq