LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/prob1.c
// Function: cal_pdg
static int cal_pdg(const bcf1_t *b, bcf_p1aux_t *ma)
{
    int i, j;
    long *p, tmp;
    p = alloca(b->n_alleles * sizeof(long));
    memset(p, 0, sizeof(long) * b->n_alleles);
    for (j = 0; j < ma->n; ++j) {
        const uint8_t *pi = ma->PL + j * ma->PL_len;
        double *pdg = ma->pdg + j * 3;
        pdg[0] = ma->q2p[pi[2]]; pdg[1] = ma->q2p[pi[1]]; pdg[2] = ma->q2p[pi[0]];
        for (i = 0; i < b->n_alleles; ++i)
            p[i] += (int)pi[(i+1)*(i+2)/2-1];
    }
    for (i = 0; i < b->n_alleles; ++i) p[i] = p[i]<<4 | i;
    for (i = 1; i < b->n_alleles; ++i) // insertion sort
        for (j = i; j > 0 && p[j] < p[j-1]; --j)
            tmp = p[j], p[j] = p[j-1], p[j-1] = tmp;
    for (i = b->n_alleles - 1; i >= 0; --i)
        if ((p[i]&0xf) == 0) break;
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movslq 0x58(%rdi), %rbx
movl %ebx, %r12d
movq %rsp, %r14
leaq 0xf(,%rbx,8), %rax
movq %rbx, %rdx
shlq $0x3, %rdx
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movq %r14, %rdi
xorl %esi, %esi
callq 0x21f0
movslq (%r15), %rax
testq %rax, %rax
jle 0x14658
movq 0xa0(%r15), %rcx
movslq 0xa8(%r15), %rdx
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdi
movq %r12, %r8
negq %r8
xorl %r9d, %r9d
movq %r9, %r10
imulq %rdx, %r10
leaq (%r9,%r9,2), %r11
movzbl 0x2(%rcx,%r10), %r15d
movsd (%rsi,%r15,8), %xmm0
movsd %xmm0, (%rdi,%r11,8)
movzbl 0x1(%rcx,%r10), %r15d
movsd (%rsi,%r15,8), %xmm0
movsd %xmm0, 0x8(%rdi,%r11,8)
movzbl (%rcx,%r10), %r15d
movsd (%rsi,%r15,8), %xmm0
movsd %xmm0, 0x10(%rdi,%r11,8)
testl %ebx, %ebx
jle 0x14650
addq %rcx, %r10
movl $0x1, %r11d
leaq 0x1(%r11), %r15
movl %r15d, %r13d
imull %r11d, %r13d
shrl %r13d
movzbl -0x1(%r10,%r13), %r13d
addq %r13, -0x8(%r14,%r11,8)
leaq (%r8,%r11), %r13
incq %r13
movq %r15, %r11
cmpq $0x1, %r13
jne 0x14627
incq %r9
cmpq %rax, %r9
jne 0x145d8
testl %ebx, %ebx
jle 0x14675
xorl %eax, %eax
movq (%r14,%rax,8), %rcx
shlq $0x4, %rcx
orq %rax, %rcx
movq %rcx, (%r14,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x1465e
cmpl $0x2, %ebx
jl 0x146ac
movl $0x1, %eax
movl $0x2, %ecx
movl %ecx, %edx
decl %edx
movq -0x8(%r14,%rdx,8), %rdi
movq (%r14,%rdx,8), %rsi
cmpq %rdi, %rsi
jge 0x146a4
movq %rdi, (%r14,%rdx,8)
movq %rsi, -0x8(%r14,%rdx,8)
cmpl $0x1, %edx
jg 0x14686
incl %eax
incl %ecx
cmpl %ebx, %eax
jne 0x14684
movl %ebx, %eax
sarl $0x1f, %eax
andl %ebx, %eax
decl %eax
decq %r12
testl %ebx, %ebx
jle 0x146cd
movl %r12d, %ecx
decl %ebx
decq %r12
testb $0xf, (%r14,%rcx,8)
jne 0x146b8
jmp 0x146cf
movl %eax, %ebx
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/em.c
// Function: get_pdg3
static double *get_pdg3(const bcf1_t *b)
{
	double *pdg;
	const uint8_t *PL = 0;
	int i, PL_len = 0;
	// initialize g_q2p if necessary
	if (g_q2p[0] == 0.)
		for (i = 0; i < 256; ++i)
			g_q2p[i] = pow(10., -i / 10.);
	// set PL and PL_len
	for (i = 0; i < b->n_gi; ++i) {
		if (b->gi[i].fmt == bcf_str2int("PL", 2)) {
			PL = (const uint8_t*)b->gi[i].data;
			PL_len = b->gi[i].len;
			break;
		}
	}
	if (i == b->n_gi) return 0; // no PL
	// fill pdg
	pdg = malloc(3 * b->n_smpl * sizeof(double));
	for (i = 0; i < b->n_smpl; ++i) {
		const uint8_t *pi = PL + i * PL_len;
		double *p = pdg + i * 3;
		p[0] = g_q2p[pi[2]]; p[1] = g_q2p[pi[1]]; p[2] = g_q2p[pi[0]];
	}
	return pdg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0xb0f5(%rip), %xmm0     # 0x20440
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1538f
jp 0x1538f
leaq 0xb0e2(%rip), %r14      # 0x20440
xorl %r15d, %r15d
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
movsd 0x609f(%rip), %xmm0     # 0x1b410
divsd %xmm0, %xmm1
callq 0x2160
movsd %xmm0, (%r14)
decq %r15
addq $0x8, %r14
cmpq $-0x100, %r15
jne 0x15361
movl 0x48(%rbx), %eax
testl %eax, %eax
jle 0x153bc
movq 0x50(%rbx), %rdx
addq $0x8, %rdx
xorl %ecx, %ecx
cmpl $0x504c, -0x8(%rdx)     # imm = 0x504C
je 0x153c6
incq %rcx
addq $0x10, %rdx
cmpq %rcx, %rax
jne 0x153a0
xorl %r14d, %r14d
movl %eax, %ecx
jmp 0x153c1
xorl %ecx, %ecx
xorl %r14d, %r14d
xorl %r15d, %r15d
jmp 0x153cd
movq (%rdx), %r15
movslq -0x4(%rdx), %r14
cmpl %eax, %ecx
jne 0x153d5
xorl %eax, %eax
jmp 0x15439
movslq 0x5c(%rbx), %r12
leaq (,%r12,8), %rax
leaq (%rax,%rax,2), %rbx
movq %rbx, %rdi
callq 0x2360
testq %r12, %r12
jle 0x15439
addq $0x2, %r15
xorl %ecx, %ecx
leaq 0xb041(%rip), %rdx      # 0x20440
movzbl (%r15), %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rcx)
movzbl -0x1(%r15), %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, 0x8(%rax,%rcx)
movzbl -0x2(%r15), %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, 0x10(%rax,%rcx)
addq $0x18, %rcx
addq %r14, %r15
cmpq %rcx, %rbx
jne 0x153ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x154b7
movl %edi, %eax
addq $0x10, %rsi
movsd 0x3ba8(%rip), %xmm0     # 0x19010
movl $0x2, %ecx
movsd -0x10(%rsi), %xmm1
ucomisd %xmm0, %xmm1
jne 0x15493
jp 0x15493
movsd -0x8(%rsi), %xmm2
ucomisd %xmm0, %xmm2
jne 0x15493
jp 0x15493
movsd (%rsi), %xmm2
ucomisd %xmm0, %xmm2
jne 0x15493
jnp 0x154ae
xorl %edx, %edx
ucomisd -0x8(%rsi), %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 0x1546d
movl -0x8(%rsp), %ecx
movl -0x4(%rsp), %edx
movl -0xc(%rsp), %eax
addl %ecx, %eax
addl %edx, %eax
je 0x154ef
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd 0x3b39(%rip), %xmm0     # 0x19018
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
retq
movsd 0x3b39(%rip), %xmm0     # 0x19030
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x18, %rsp
movsd %xmm0, (%rsp)
movl %edi, %eax
movl %esi, %ecx
subl %edi, %ecx
addl %ecx, %ecx
cvtsi2sd %ecx, %xmm1
leaq (%rax,%rax,2), %rcx
xorl %eax, %eax
movsd 0x3af5(%rip), %xmm2     # 0x19010
movapd 0x619d(%rip), %xmm3     # 0x1b6c0
movsd 0x617d(%rip), %xmm4     # 0x1b6a8
movapd %xmm0, %xmm6
xorpd %xmm5, %xmm5
cmpl %edi, %esi
jle 0x155c0
movapd %xmm2, %xmm7
subsd %xmm6, %xmm7
movapd %xmm6, %xmm8
addsd %xmm6, %xmm8
mulsd %xmm7, %xmm8
mulsd %xmm7, %xmm7
movapd %xmm6, %xmm9
mulsd %xmm6, %xmm9
movq %rcx, %r8
movl %edi, %r9d
movl %r8d, %r10d
movsd 0x10(%rdx,%r10,8), %xmm10
movapd %xmm10, %xmm11
addsd %xmm10, %xmm11
movsd 0x8(%rdx,%r10,8), %xmm12
mulsd %xmm9, %xmm11
mulsd %xmm8, %xmm12
movsd (%rdx,%r10,8), %xmm13
mulsd %xmm7, %xmm13
addsd %xmm12, %xmm11
addsd %xmm12, %xmm13
mulsd %xmm9, %xmm10
addsd %xmm13, %xmm10
divsd %xmm10, %xmm11
addsd %xmm11, %xmm5
incl %r9d
addq $0x3, %r8
cmpl %esi, %r9d
jl 0x15566
divsd %xmm1, %xmm5
movapd %xmm5, %xmm7
subsd %xmm6, %xmm7
andpd %xmm3, %xmm7
ucomisd %xmm7, %xmm4
ja 0x155ea
incl %eax
movapd %xmm5, %xmm6
cmpl $0xa, %eax
jne 0x1552f
movl $0xa, %eax
movsd %xmm5, (%rsp)
cmpl $0xa, %eax
jne 0x15645
leaq 0x8(%rsp), %rax
movl %edi, (%rax)
movl %esi, 0x4(%rax)
movq %rdx, 0x8(%rax)
movq %rsp, %rdx
movsd (%rdx), %xmm1
movsd 0x3a07(%rip), %xmm2     # 0x19018
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm3
cmpeqsd %xmm0, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm0, %xmm3
orpd %xmm2, %xmm3
leaq 0x5a5(%rip), %rdi       # 0x15bd6
movsd 0x606f(%rip), %xmm2     # 0x1b6a8
movapd %xmm3, %xmm0
movq %rax, %rsi
callq 0x168b9
movsd (%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorpd %xmm2, %xmm2
movl %ecx, %eax
xorpd %xmm3, %xmm3
xorpd %xmm1, %xmm1
subl %edx, %eax
jle 0x156e0
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm4
movsd 0x10(%rdi), %xmm5
cvtsi2sd %eax, %xmm6
movslq %edx, %rdx
movslq %ecx, %rax
leaq (%rdx,%rdx,2), %rcx
leaq (%rsi,%rcx,8), %rcx
addq $0x10, %rcx
subq %rdx, %rax
movsd -0x10(%rcx), %xmm7
mulsd %xmm0, %xmm7
movsd -0x8(%rcx), %xmm8
mulsd %xmm4, %xmm8
movsd (%rcx), %xmm9
mulsd %xmm5, %xmm9
movapd %xmm7, %xmm10
addsd %xmm8, %xmm10
addsd %xmm9, %xmm10
mulsd %xmm6, %xmm10
divsd %xmm10, %xmm7
addsd %xmm7, %xmm2
divsd %xmm10, %xmm8
addsd %xmm8, %xmm3
divsd %xmm10, %xmm9
addsd %xmm9, %xmm1
addq $0x18, %rcx
decq %rax
jne 0x15688
movapd %xmm2, %xmm0
subsd (%rdi), %xmm0
movapd 0x5fd0(%rip), %xmm4     # 0x1b6c0
movapd %xmm3, %xmm5
subsd 0x8(%rdi), %xmm5
andpd %xmm4, %xmm0
andpd %xmm4, %xmm5
maxsd %xmm5, %xmm0
movapd %xmm1, %xmm5
subsd 0x10(%rdi), %xmm5
andpd %xmm4, %xmm5
maxsd %xmm5, %xmm0
movsd %xmm2, (%rdi)
movsd %xmm3, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x157c8
movsd 0x18(%rcx), %xmm1
movsd 0x20(%rcx), %xmm2
movsd 0x28(%rcx), %xmm3
movsd (%rcx), %xmm4
movsd 0x8(%rcx), %xmm5
movsd 0x10(%rcx), %xmm6
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
movsd 0x38b4(%rip), %xmm0     # 0x19010
xorl %r8d, %r8d
movsd (%rdx,%r8), %xmm7
movsd 0x8(%rdx,%r8), %xmm8
movapd %xmm8, %xmm9
mulsd %xmm2, %xmm9
movapd %xmm7, %xmm10
movsd 0x10(%rdx,%r8), %xmm11
movapd %xmm11, %xmm12
mulsd %xmm1, %xmm10
mulsd %xmm3, %xmm12
mulsd %xmm5, %xmm8
mulsd %xmm4, %xmm7
addsd %xmm9, %xmm10
addsd %xmm8, %xmm7
mulsd %xmm6, %xmm11
addsd %xmm7, %xmm11
addsd %xmm10, %xmm12
divsd %xmm11, %xmm12
mulsd %xmm12, %xmm0
addq $0x18, %r8
cmpq %r8, %rax
jne 0x1575f
jmp 0x157d2
movsd 0x3840(%rip), %xmm0     # 0x19010
xorl %esi, %esi
cmpl %edi, %esi
jge 0x1586d
movsd 0x30(%rcx), %xmm1
movsd 0x38(%rcx), %xmm2
movsd 0x40(%rcx), %xmm3
movsd (%rcx), %xmm4
movsd 0x8(%rcx), %xmm5
movsd 0x10(%rcx), %xmm6
movl %esi, %esi
movl %edi, %eax
leaq (%rsi,%rsi,2), %rcx
leaq (%rdx,%rcx,8), %rcx
addq $0x10, %rcx
subq %rsi, %rax
movsd -0x10(%rcx), %xmm7
movsd -0x8(%rcx), %xmm8
movapd %xmm8, %xmm9
mulsd %xmm2, %xmm9
movapd %xmm7, %xmm10
movsd (%rcx), %xmm11
movapd %xmm11, %xmm12
mulsd %xmm1, %xmm10
mulsd %xmm3, %xmm12
mulsd %xmm5, %xmm8
mulsd %xmm4, %xmm7
addsd %xmm9, %xmm10
addsd %xmm8, %xmm7
mulsd %xmm6, %xmm11
addsd %xmm7, %xmm11
addsd %xmm10, %xmm12
divsd %xmm11, %xmm12
mulsd %xmm12, %xmm0
addq $0x18, %rcx
decq %rax
jne 0x1580a
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5ac6(%rip), %xmm1     # 0x1b6b0
ja 0x15d13
ucomisd 0x3418(%rip), %xmm3     # 0x19010
ja 0x15d13
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd 0x33fe(%rip), %xmm0     # 0x19010
movslq (%rdi), %r14
cmpl 0x4(%rdi), %r14d
jge 0x15cf3
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), %rax
leaq 0x10(,%rax,8), %r15
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd 0x33b8(%rip), %xmm1     # 0x19010
movsd 0x5a58(%rip), %xmm6     # 0x1b6b8
movsd %xmm3, 0x18(%rsp)
movsd %xmm4, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
movq 0x8(%rbx), %rax
movsd -0x8(%rax,%r15), %xmm0
mulsd %xmm4, %xmm0
movsd -0x10(%rax,%r15), %xmm2
mulsd %xmm5, %xmm2
addsd %xmm0, %xmm2
movsd (%rax,%r15), %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
ucomisd %xmm0, %xmm6
jbe 0x15cdd
callq 0x2210
movsd 0x5a03(%rip), %xmm6     # 0x1b6b8
movsd 0x8(%rsp), %xmm5
movsd 0x10(%rsp), %xmm4
movsd 0x18(%rsp), %xmm3
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x3333(%rip), %xmm0     # 0x19010
incq %r14
movslq 0x4(%rbx), %rax
addq $0x18, %r15
movapd %xmm0, %xmm1
cmpq %rax, %r14
jl 0x15c72
jmp 0x15cfc
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
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movapd %xmm0, %xmm3
movsd %xmm0, 0x8(%rsp)
movsd 0x59a2(%rip), %xmm0     # 0x1b6d0
addsd %xmm3, %xmm0
movsd 0x599e(%rip), %xmm1     # 0x1b6d8
divsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x5992(%rip), %xmm1     # 0x1b6e0
addsd %xmm3, %xmm1
movsd 0x598e(%rip), %xmm2     # 0x1b6e8
divsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd 0x5986(%rip), %xmm0     # 0x1b6f0
addsd %xmm3, %xmm0
movsd 0x5982(%rip), %xmm1     # 0x1b6f8
divsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd 0x5692(%rip), %xmm0     # 0x1b418
addsd %xmm3, %xmm0
movsd 0x596e(%rip), %xmm2     # 0x1b700
divsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd 0x5966(%rip), %xmm0     # 0x1b708
addsd %xmm3, %xmm0
movsd 0x5962(%rip), %xmm1     # 0x1b710
divsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd 0x5662(%rip), %xmm0     # 0x1b420
addsd %xmm3, %xmm0
movsd 0x594e(%rip), %xmm2     # 0x1b718
divsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd 0x3236(%rip), %xmm0     # 0x19010
addsd %xmm3, %xmm0
movsd 0x593a(%rip), %xmm1     # 0x1b720
divsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd 0x5932(%rip), %xmm0     # 0x1b728
divsd %xmm3, %xmm0
addsd %xmm1, %xmm0
addsd 0x592a(%rip), %xmm0     # 0x1b730
callq 0x2210
addsd 0x5925(%rip), %xmm0     # 0x1b738
movsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x5915(%rip), %xmm0     # 0x1b740
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
addsd 0x590c(%rip), %xmm1     # 0x1b748
movapd %xmm1, %xmm0
callq 0x2210
mulsd (%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2fca(%rip), %xmm1     # 0x19010
movl $0x1, %eax
movsd 0x579d(%rip), %xmm0     # 0x1b7f0
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 0x1608e
leal 0x1(%rax), %ecx
cmpl $0x63, %eax
movl %ecx, %eax
jne 0x16057
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 0x2f48(%rip), %xmm1     # 0x19010
movapd %xmm1, %xmm0
callq 0x15d18
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_O1/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 0x2f06(%rip), %xmm0     # 0x19010
addsd %xmm1, %xmm0
subsd %xmm10, %xmm0
xorpd %xmm1, %xmm1
movl $0x1, %ecx
movl $0x3, %eax
movsd 0x56cf(%rip), %xmm2     # 0x1b7f8
movsd 0x2edf(%rip), %xmm3     # 0x19010
movsd 0x2ef7(%rip), %xmm4     # 0x19030
movapd 0x557f(%rip), %xmm5     # 0x1b6c0
movsd 0x56a7(%rip), %xmm6     # 0x1b7f0
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 0x161cc
leal 0x1(%rcx), %edx
addl $0x2, %eax
cmpl $0x63, %ecx
movl %edx, %ecx
jne 0x1614e
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 0x15d18
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_O1/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 0x162dc
jp 0x162dc
retq
movsd 0x2d2c(%rip), %xmm0     # 0x19010
ucomisd %xmm0, %xmm2
jne 0x162ec
jnp 0x162db
movapd %xmm12, %xmm0
addsd %xmm1, %xmm0
movl $0x1, %eax
xorpd %xmm7, %xmm7
movsd 0x2d09(%rip), %xmm13    # 0x19010
movsd 0x2d20(%rip), %xmm14    # 0x19030
movsd 0x54e0(%rip), %xmm3     # 0x1b7f8
movapd 0x53a0(%rip), %xmm4     # 0x1b6c0
movsd 0x54c8(%rip), %xmm5     # 0x1b7f0
movapd 0x54d0(%rip), %xmm6     # 0x1b800
movapd %xmm13, %xmm8
movapd %xmm13, %xmm15
movl %eax, %ecx
shrl %ecx
xorps %xmm9, %xmm9
cvtsi2sd %ecx, %xmm9
testb $0x1, %al
jne 0x16363
movapd %xmm1, %xmm10
subsd %xmm9, %xmm10
mulsd %xmm10, %xmm9
movl %eax, %ecx
movapd %xmm14, %xmm10
jmp 0x16389
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 0x1640d
leal 0x1(%rax), %ecx
cmpl $0xc7, %eax
movl %ecx, %eax
jne 0x1633a
subq $0x28, %rsp
movsd %xmm12, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm15, 0x20(%rsp)
callq 0x15d18
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x15d18
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x15d18
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 0x2b86(%rip), %xmm0     # 0x19010
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_O1/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 0x1689d
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 0x1682f
incl %ebx
movsd %xmm0, 0x8(%rsp)
movq %r13, %rcx
jmp 0x1688f
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 0x16875
movsd %xmm0, 0x8(%rsp)
jmp 0x16887
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 0x167f5
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_O1/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 0x17301
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x172eb
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 0x172cf
movq 0x8(%rbx), %rdi
callq 0x2060
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x454a(%rip), %rsi      # 0x1b862
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8581
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8581
cmpl $0x0, (%r14)
jle 0x1737b
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %r13
leaq (%r15,%r13), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8581
movq 0x8(%r13,%r15), %rsi
movslq (%r13,%r15), %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
callq 0x8581
incq %r12
movslq (%r14), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x17341
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3721(%rip), %rsi      # 0x1aab8
callq 0x7998
testq %rax, %rax
je 0x17467
movq %rax, %rbx
leaq 0x4(%rsp), %r14
movl $0x4, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x80ee
cmpl $0x4494342, (%r14)      # imm = 0x4494342
jne 0x1747c
movl $0x1, %edi
movl $0x10, %esi
callq 0x2260
movq %rax, %r14
movl $0x4, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x80ee
movslq (%r14), %r15
movl $0x10, %esi
movq %r15, %rdi
callq 0x2260
movq %rax, 0x8(%r14)
testq %r15, %r15
jle 0x1745d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rbp
leaq (%r12,%rbp), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x80ee
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 0x80ee
incq %r13
movslq (%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x1740b
movq %rbx, %rdi
callq 0x868e
jmp 0x1746a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b7f
xorl %r14d, %r14d
jmp 0x1745d
// File: /workspace/github_c_makefile_star2_O1/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 0x3a08(%rip), %rsi      # 0x1aed7
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x17514
leaq 0x3a3b(%rip), %rsi      # 0x1af22
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x17514
movq %rbx, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x17559
movq %r14, %rbx
xorl %r14d, %r14d
jmp 0x17551
movq %rbx, %rdi
callq 0x2180
cltq
addq %rbx, %rax
decq %rax
movq %rax, %rdi
cmpq %rbx, %rax
jb 0x17535
leaq -0x1(%rdi), %rax
cmpb $0x2f, (%rdi)
jne 0x17524
incq %rdi
callq 0x2510
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2190
testl %eax, %eax
jne 0x17583
movq %rbx, %rdi
callq 0x2060
testq %r14, %r14
je 0x17576
movq %r14, %rdi
callq 0x17385
movq %rax, %rbx
movq %r14, %rdi
callq 0x2060
movq %rbx, %rax
jmp 0x17578
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
sete %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2ba4
testb $0x1, %al
je 0x174fb
jmp 0x17559
// File: /workspace/github_c_makefile_star2_O1/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 0x3508(%rip), %rsi      # 0x1aab8
callq 0xb3a4
testq %rax, %rax
je 0x17673
movq %rax, %r12
movq %rax, %rdi
callq 0xb51c
movq %r12, %rdi
movq %rax, %rsi
callq 0x1708c
movq %rax, %rbx
movq %r12, %rdi
callq 0xb432
testq %r14, %r14
je 0x175f1
movq %r14, %rdi
callq 0x2510
movq %rax, %r14
jmp 0x1762b
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 0x1c18(%rip), %rsi      # 0x1924a
movq %r14, %rdi
callq 0x7998
testq %rax, %rax
je 0x1767a
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17302
movq %rbx, %rdi
callq 0x172b4
movq %r15, %rdi
callq 0x868e
movq %r14, %rdi
callq 0x2060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2d54
jmp 0x17685
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d17
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x17667
// File: /workspace/github_c_makefile_star2_O1/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, 0x8(%rsp)
movq %rcx, (%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, 0x10(%rsp)
xorl %r14d, %r14d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0x0, %r13d
andq %rbx, %r12
je 0x1771d
xorl %ebx, %ebx
xorl %r13d, %r13d
movsbq (%rbp,%rbx), %r15
cmpq $0x2c, %r15
je 0x17715
callq 0x2580
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
jne 0x17715
movslq %r13d, %rax
incl %r13d
movq 0x10(%rsp), %rcx
movb %r15b, (%rcx,%rax)
incq %rbx
cmpq %rbx, %r12
jne 0x176ea
movl %r13d, %ebx
movslq %r13d, %rax
movq 0x10(%rsp), %r13
movb $0x0, (%r13,%rax)
testl %eax, %eax
sete %bpl
je 0x17760
cmpb $0x3a, (%r13)
je 0x17760
leaq -0x1(%rbx), %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
sete %bpl
je 0x1775d
leaq 0x1(%rcx), %r14
cmpb $0x3a, 0x1(%r13,%rcx)
movq %r14, %rcx
jne 0x17743
jmp 0x17760
movl %ebx, %r14d
movl %r14d, %r12d
movb $0x0, (%r13,%r12)
movq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0xe599
movq 0x20(%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
js 0x177a7
testb %bpl, %bpl
je 0x177b6
movq (%rsp), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
movl $0x20000000, (%rax)     # imm = 0x20000000
movq %r13, %rdi
callq 0x2060
xorl %eax, %eax
jmp 0x17826
movq %r13, %rdi
callq 0x2060
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x17826
leaq (%r12,%r13), %rdi
incq %rdi
cmpl %ebx, %r14d
je 0x177da
cmpb $0x2d, (%r13,%r12)
je 0x177d7
incq %r12
cmpq %r12, %rbx
jne 0x177c2
movl %ebx, %r14d
jmp 0x177da
movl %r12d, %r14d
callq 0x2470
movq (%rsp), %r15
movl %eax, (%r15)
movl $0x20000000, %eax       # imm = 0x20000000
cmpl %ebx, %r14d
jge 0x177ff
movl %r14d, %eax
leaq (%rax,%r13), %rdi
incq %rdi
callq 0x2470
movq 0x8(%rsp), %rbx
movl %eax, (%rbx)
movl (%r15), %eax
testl %eax, %eax
jle 0x17812
decl %eax
movl %eax, (%r15)
movq %r13, %rdi
callq 0x2060
movl (%r15), %ecx
xorl %eax, %eax
cmpl (%rbx), %ecx
setg %al
negl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1786f
movl %edx, %esi
leal (%rsi,%rax), %edi
subl %eax, %edi
cmpq $0x0, (%rcx,%rax,8)
jne 0x1786f
incq %rax
cmpq %rax, %rdi
jne 0x1785e
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_O1/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 0x1789b
movq 0x8(%rsi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x1759b
movl %ebx, %eax
popq %rbx
retq
callq 0x2d70
movl $0x1, %ebx
jmp 0x17897
nop
// File: /workspace/github_c_makefile_star2_O1/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bcftools/mut.c
// Function: bcf_trio_prep
uint32_t *bcf_trio_prep(int is_x, int is_son)
{
	int i, j, k, n, map[10];
	uint32_t *ret;
	ret = calloc(MAX_GENO, 4);
	for (i = 0, k = 0; i < 4; ++i)
		for (j = i; j < 4; ++j)
			map[k++] = 1<<i|1<<j;
	for (i = 0, n = 1; i < 10; ++i) { // father
		if (is_x && seq_bitcnt[map[i]] != 1) continue;
		if (is_x && is_son) {
			for (j = 0; j < 10; ++j) // mother
				for (k = 0; k < 10; ++k) // child
					if (seq_bitcnt[map[k]] == 1 && (map[j]&map[k]))
						ret[n++] = j<<16 | i<<8 | k;
		} else {
			for (j = 0; j < 10; ++j) // mother
				for (k = 0; k < 10; ++k) // child
					if ((map[i]&map[k]) && (map[j]&map[k]) && ((map[i]|map[j])&map[k]) == map[k])
						ret[n++] = j<<16 | i<<8 | k;
		}
	}
	ret[0] = n - 1;
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
movl $0x167, %edi            # imm = 0x167
movl $0x4, %esi
callq 0x2260
xorl %ecx, %ecx
movl $0x4, %edx
xorl %esi, %esi
movl $0x1, %edi
shll %cl, %edi
movslq %esi, %rsi
leaq (%rsp,%rsi,4), %r8
addl %edx, %esi
movl %ecx, %r9d
movl %edi, %r10d
btsl %r9d, %r10d
movl %r10d, (%r8)
incl %r9d
addq $0x4, %r8
cmpl $0x4, %r9d
jne 0x17c85
incl %ecx
decl %edx
cmpl $0x4, %ecx
jne 0x17c72
testl %ebx, %ebx
setne %cl
testl %ebp, %ebp
setne %dl
andb %cl, %dl
movl $0x1, %ecx
xorl %esi, %esi
leaq 0x8751(%rip), %rdi      # 0x20410
xorl %r8d, %r8d
testl %ebx, %ebx
je 0x17cd5
movslq (%rsp,%r8,4), %r9
cmpb $0x1, (%r9,%rdi)
jne 0x17d6b
testb %dl, %dl
je 0x17d1b
movq %rsi, %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
movslq (%rsp,%r11,4), %r14
cmpb $0x1, (%r14,%rdi)
jne 0x17d00
testl %r14d, (%rsp,%r10,4)
je 0x17d00
movslq %ecx, %r14
incl %ecx
leal (%r9,%r11), %ebp
movl %ebp, (%rax,%r14,4)
incq %r11
cmpq $0xa, %r11
jne 0x17ce2
incq %r10
addq $0x10000, %r9           # imm = 0x10000
cmpq $0xa, %r10
jne 0x17cdf
jmp 0x17d6b
movl (%rsp,%r8,4), %r9d
movq %rsi, %r10
xorl %r11d, %r11d
xorl %r14d, %r14d
movl (%rsp,%r14,4), %ebp
testl %r9d, %ebp
je 0x17d52
movl (%rsp,%r11,4), %r15d
testl %ebp, %r15d
je 0x17d52
orl %r9d, %r15d
notl %r15d
testl %r15d, %ebp
jne 0x17d52
movslq %ecx, %r15
incl %ecx
leal (%r10,%r14), %ebp
movl %ebp, (%rax,%r15,4)
incq %r14
cmpq $0xa, %r14
jne 0x17d28
incq %r11
addq $0x10000, %r10          # imm = 0x10000
cmpq $0xa, %r11
jne 0x17d25
incq %r8
addq $0x100, %rsi            # imm = 0x100
cmpq $0xa, %r8
jne 0x17cc2
decl %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x180ed
movl 0x48(%rdi), %ecx
testl %ecx, %ecx
jle 0x18033
movq 0x50(%rdi), %rsi
xorl %edx, %edx
cmpl $0x504c, (%rsi)         # imm = 0x504C
je 0x18035
incq %rdx
addq $0x10, %rsi
cmpq %rdx, %rcx
jne 0x1801b
movl %ecx, %edx
jmp 0x18035
xorl %edx, %edx
cmpl %ecx, %edx
je 0x180ed
movq 0x50(%rdi), %rax
movl %edx, %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rdx
movslq 0x4(%rax,%rcx), %rcx
movl $0x1, %eax
movq %rdx, %rsi
cmpb $0x0, (%rsi)
jne 0x18069
addq %rcx, %rsi
decq %rax
je 0x18059
xorl %eax, %eax
retq
movq %rdx, -0x18(%rsp)
leaq (%rdx,%rcx), %rsi
movq %rsi, -0x10(%rsp)
testl %ecx, %ecx
jle 0x180a3
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 0x18083
jmp 0x180a8
movl $0x40000000, %eax       # imm = 0x40000000
movl %ecx, %edx
xorl %esi, %esi
xorl %edi, %edi
testl %ecx, %ecx
jle 0x180d6
movq -0x18(%rsp,%rsi,8), %r9
movl $0x40000000, %r8d       # imm = 0x40000000
xorl %r10d, %r10d
movzbl (%r9,%r10), %r11d
cmpl %r11d, %r8d
cmovgel %r11d, %r8d
incq %r10
cmpq %r10, %rdx
jne 0x180c0
jmp 0x180dc
movl $0x40000000, %r8d       # imm = 0x40000000
addl %r8d, %edi
leaq 0x1(%rsi), %r8
testq %rsi, %rsi
movq %r8, %rsi
je 0x180ae
subl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x48(%rdi), %ecx
testl %ecx, %ecx
jle 0x18113
movq 0x50(%rdi), %rax
xorl %edx, %edx
cmpl $0x504c, (%rax)         # imm = 0x504C
je 0x18115
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x180fb
movl %ecx, %edx
jmp 0x18115
xorl %edx, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %edx
je 0x1818a
movl 0x5c(%rdi), %ecx
testl %ecx, %ecx
jle 0x1818b
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 0x1817d
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 0x18158
subl %r10d, %r8d
cmpl %r8d, %eax
cmovgel %r8d, %eax
incl %edi
cmpl %ecx, %edi
jne 0x1813f
retq
movl $0x40000000, %eax       # imm = 0x40000000
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]unix-samples/lab/pollsig1.c
// Function: main
int
main()
{
	struct pollfd pfd[1];

	int pip[2];
	errwrap(pipe(pip));

	int pid;

	errwrap(pid = fork());
	if (pid == 0) {
		sleep(5);
		fprintf(stderr, "Okay thxbye\n");
		exit(0);
	}

	// now we "wait"
	pfd[0].fd = pip[0];
	pfd[0].events = POLLIN;
	// note that by default this WON'T exit, with SIGCHLD's default
	// behavior.
	int n = poll(pfd, 1, INFTIM);
	if (n == -1 && errno == EINTR) {
		fprintf(stderr, "Everything is okay\n");
	}
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rdi
callq 0x1040
cmpl $-0x1, %eax
je 0x125a
callq 0x10a0
testl %eax, %eax
je 0x1263
cmpl $-0x1, %eax
je 0x1268
movl 0x8(%rsp), %eax
leaq 0x10(%rsp), %rdi
movl %eax, (%rdi)
movw $0x1, 0x4(%rdi)
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1060
cmpl $-0x1, %eax
jne 0x124c
callq 0x1030
cmpl $0x4, (%rax)
je 0x1253
xorl %eax, %eax
addq $0x18, %rsp
retq
callq 0x10ec
jmp 0x124c
leaq 0xda3(%rip), %rsi       # 0x2004
jmp 0x126f
callq 0x10c0
leaq 0xd9f(%rip), %rsi       # 0x200e
movl $0x1, %edi
xorl %eax, %eax
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/quicklist.c
// Function: quicklistNodeAllowInsert
REDIS_STATIC int _quicklistNodeAllowInsert(const quicklistNode *node,
                                           const int fill, const size_t sz) {
    if (unlikely(!node))
        return 0;

    int ziplist_overhead;
    /* size of previous offset */
    if (sz < 254)
        ziplist_overhead = 1;
    else
        ziplist_overhead = 5;

    /* size of forward offset */
    if (sz < 64)
        ziplist_overhead += 1;
    else if (likely(sz < 16384))
        ziplist_overhead += 2;
    else
        ziplist_overhead += 5;

    /* new_sz overestimates if 'sz' encodes to an integer type */
    unsigned int new_sz = node->sz + sz + ziplist_overhead;
    if (likely(_quicklistNodeSizeMeetsOptimizationRequirement(new_sz, fill)))
        return 1;
    else if (!sizeMeetsSafetyLimit(new_sz))
        return 0;
    else if ((int)node->count < fill)
        return 1;
    else
        return 0;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x26d96
xorl %ecx, %ecx
cmpq $0xfe, %rdx
setae %cl
leal 0x1(,%rcx,4), %ecx
cmpq $0x3f, %rdx
ja 0x26d54
incl %ecx
jmp 0x26d60
cmpq $0x3fff, %rdx           # imm = 0x3FFF
ja 0x26d97
orl $0x2, %ecx
addl %ecx, %edx
addl 0x18(%rdi), %edx
cmpl $-0x5, %esi
jb 0x26d83
movl %edx, %ecx
movl %esi, %r8d
notl %r8d
leaq 0x982a7(%rip), %r9      # 0xbf020
cmpq %rcx, (%r9,%r8,8)
jb 0x26d83
pushq $0x1
popq %rax
retq
cmpl $0x2000, %edx           # imm = 0x2000
ja 0x26d96
movzwl 0x1c(%rdi), %ecx
xorl %eax, %eax
cmpl %esi, %ecx
setl %al
retq
addl $0x5, %ecx
jmp 0x26d60
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/quicklist.c
// Function: quicklistPushHead
int quicklistPushHead(quicklist *quicklist, void *value, size_t sz) {
    quicklistNode *orig_head = quicklist->head;
    if (likely(
            _quicklistNodeAllowInsert(quicklist->head, quicklist->fill, sz))) {
        quicklist->head->zl =
            ziplistPush(quicklist->head->zl, value, sz, ZIPLIST_HEAD);
        quicklistNodeUpdateSz(quicklist->head);
    } else {
        quicklistNode *node = quicklistCreateNode();
        node->zl = ziplistPush(ziplistNew(), value, sz, ZIPLIST_HEAD);

        quicklistNodeUpdateSz(node);
        _quicklistInsertNodeBefore(quicklist, quicklist->head, node);
    }
    quicklist->count++;
    quicklist->head->count++;
    return (orig_head != quicklist->head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %r14
movswl 0x1c(%rdi), %esi
movq %r14, %rdi
callq 0x26d30
testl %eax, %eax
je 0x26e04
movq 0x10(%r14), %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x3ea1e
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rax, %rdi
callq 0x3ef6d
movq (%rbx), %rcx
movl %eax, 0x18(%rcx)
incq 0x10(%rbx)
movq (%rbx), %rax
incw 0x1c(%rax)
xorl %eax, %eax
cmpq (%rbx), %r14
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2e809
movq %rax, %r13
callq 0x3e2e3
movq %rax, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x3ea1e
movq %rax, 0x10(%r13)
movq %rax, %rdi
callq 0x3ef6d
movl %eax, 0x18(%r13)
movq (%rbx), %rsi
movq %rbx, %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x2eacc
jmp 0x26de7