LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_hdr_destroy
void bcf_hdr_destroy(bcf_hdr_t *h)
{
	int i;
	khint_t k;
	for (i = 0; i < 3; ++i) {
		vdict_t *d = (vdict_t*)h->dict[i];
		if (d == 0) continue;
		for (k = kh_begin(d); k != kh_end(d); ++k)
			if (kh_exist(d, k)) free((char*)kh_key(d, k));
		kh_destroy(vdict, d);
		free(h->id[i]);
	}
	free(h->mem.s); free(h->text);
	free(h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0xfef8
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xfe77
jmp 0xfeea
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0xfecf
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x10(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xfec2
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x2040
jmp 0xfec4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xfe7e
movq -0x18(%rbp), %rdi
callq 0xff30
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdi
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfe53
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_hdr_read
bcf_hdr_t *bcf_hdr_read(BGZF *fp)
{
	uint8_t magic[5];
	bcf_hdr_t *h;
	h = bcf_hdr_init();
	bgzf_read(fp, magic, 5);
	if (strncmp((char*)magic, "BCF\2\2", 5) != 0) {
		if (hts_verbose >= 2)
			fprintf(stderr, "[E::%s] invalid BCF2 magic string\n", __func__);
		bcf_hdr_destroy(h);
		return 0;
	}
	bgzf_read(fp, &h->l_text, 4);
	h->m_text = h->l_text;
	h->text = (char*)malloc(h->l_text);
	bgzf_read(fp, h->text, h->l_text);
	bcf_hdr_parse(h);
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0xfde0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x15(%rbp), %rsi
movl $0x5, %edx
callq 0x51f0
leaq -0x15(%rbp), %rdi
leaq 0x18226(%rip), %rsi     # 0x281d8
movl $0x5, %edx
callq 0x2080
cmpl $0x0, %eax
je 0xffff
leaq 0x1e298(%rip), %rax     # 0x2e260
cmpl $0x2, (%rax)
jl 0xffec
movq 0x1e024(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x18200(%rip), %rsi     # 0x281de
leaq 0x1821c(%rip), %rdx     # 0x28201
movb $0x0, %al
callq 0x2260
movq -0x20(%rbp), %rdi
callq 0xfe40
movq $0x0, -0x8(%rbp)
jmp 0x1005e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x51f0
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movslq (%rax), %rdi
callq 0x22f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x20(%rbp), %rax
movslq (%rax), %rdx
callq 0x51f0
movq -0x20(%rbp), %rdi
callq 0xfb00
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_clear1
void bcf_clear1(bcf1_t *v)
{
	v->rid = v->pos = v->rlen = v->unpacked = 0;
	v->qual = 0;
	v->n_info = v->n_allele = v->n_fmt = v->n_sample = 0;
	v->shared.l = v->indiv.l = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
movabsq $0xffffffffff, %rcx     # imm = 0xFFFFFFFFFF
andq 0x10(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movabsq $-0xff00000001, %rcx    # imm = 0xFFFFFF00FFFFFFFF
andq 0x10(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movabsq $-0xffff0001, %rcx      # imm = 0xFFFFFFFF0000FFFF
andq 0x10(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x10000, %rcx         # imm = 0xFFFF0000
orq $0x0, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_read1_core
static inline int bcf_read1_core(BGZF *fp, bcf1_t *v)
{
	uint32_t x[8];
	int ret;
	if ((ret = bgzf_read(fp, x, 32)) != 32) {
		if (ret == 0) return -1;
		return -2;
	}
	x[0] -= 24; // to exclude six 32-bit integers
	ks_resize(&v->shared, x[0]);
	ks_resize(&v->indiv, x[1]);
	memcpy(v, x + 2, 16);
	v->n_allele = x[6]>>16; v->n_info = x[6]&0xffff;
	v->n_fmt = x[7]>>24; v->n_sample = x[7]&0xffffff;
	v->shared.l = x[0], v->indiv.l = x[1];
	v->unpacked = 0;
	v->unpack_ptr = NULL;
	bgzf_read(fp, v->shared.s, v->shared.l);
	bgzf_read(fp, v->indiv.s, v->indiv.l);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
callq 0x51f0
movl %eax, -0x44(%rbp)
cmpl $0x20, %eax
je 0x102c8
cmpl $0x0, -0x44(%rbp)
jne 0x102bc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10438
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x10438
movl -0x40(%rbp), %eax
subl $0x18, %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movl -0x40(%rbp), %eax
movl %eax, %esi
callq 0x13910
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x13910
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x28(%rbp), %ecx
shrl $0x10, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x10(%rax), %rcx
andq $0xffff, %rdx           # imm = 0xFFFF
shlq $0x10, %rdx
movabsq $-0xffff0001, %rsi      # imm = 0xFFFFFFFF0000FFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl -0x28(%rbp), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x10(%rax), %rcx
andq $0xffff, %rdx           # imm = 0xFFFF
andq $-0x10000, %rcx         # imm = 0xFFFF0000
orq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
shrl $0x18, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x10(%rax), %rcx
andq $0xff, %rdx
shlq $0x20, %rdx
movabsq $-0xff00000001, %rsi    # imm = 0xFFFFFF00FFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x10(%rax), %rcx
andq $0xffffff, %rdx         # imm = 0xFFFFFF
shlq $0x28, %rdx
movabsq $0xffffffffff, %rsi     # imm = 0xFFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl -0x40(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x51f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x51f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_write1
int bcf_write1(BGZF *fp, const bcf1_t *v)
{
	uint32_t x[8];
	x[0] = v->shared.l + 24; // to include six 32-bit integers
	x[1] = v->indiv.l;
	memcpy(x + 2, v, 16);
	x[6] = (uint32_t)v->n_allele<<16 | v->n_info;
	x[7] = (uint32_t)v->n_fmt<<24 | v->n_sample;
	bgzf_write(fp, x, 32);
	bgzf_write(fp, v->shared.s, v->shared.l);
	bgzf_write(fp, v->indiv.s, v->indiv.l);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x18, %rax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
shll $0x10, %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x20, %rax
andq $0xff, %rax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shrq $0x28, %rcx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
callq 0x5a10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x5a10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x5a10
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: vcf_hdr_write
void vcf_hdr_write(htsFile *fp, const bcf_hdr_t *h)
{
	if (!fp->is_bin) {
		int l = h->l_text;
		while (l && h->text[l-1] == 0) --l; // kill the trailing zeros
		if (l && h->text[l-1] == '\n') --l;
		fwrite(h->text, 1, l, (FILE*)fp->fp);
		fputc('\n', (FILE*)fp->fp);
	} else bcf_hdr_write((BGZF*)fp->fp, h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x10ed3
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x10e64
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x10e6d
jmp 0x10e78
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10e3b
cmpl $0x0, -0x14(%rbp)
je 0x10ea1
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x10ea1
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movslq -0x14(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %esi
callq 0x2420
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movl $0xa, %edi
callq 0x21f0
jmp 0x10ee4
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10070
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/./vcf.h
// Function: bcf_enc_size
static inline void bcf_enc_size(kstring_t *s, int size, int type)
{
	if (size >= 15) {
		kputc(15<<4|type, s);
		if (size >= 128) {
			if (size >= 32768) {
				int32_t x = size;
				kputc(1<<4|BCF_BT_INT32, s);
				kputsn((char*)&x, 4, s);
			} else {
				int16_t x = size;
				kputc(1<<4|BCF_BT_INT16, s);
				kputsn((char*)&x, 2, s);
			}
		} else {
			kputc(1<<4|BCF_BT_INT8, s);
			kputc(size, s);
		}
	} else kputc(size<<4|type, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0xf, -0xc(%rbp)
jl 0x1121d
movl -0x10(%rbp), %edi
orl $0xf0, %edi
movq -0x8(%rbp), %rsi
callq 0x10ce0
cmpl $0x80, -0xc(%rbp)
jl 0x11201
cmpl $0x8000, -0xc(%rbp)     # imm = 0x8000
jl 0x111d8
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movl $0x13, %edi
callq 0x10ce0
movq -0x8(%rbp), %rdx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x10ab0
jmp 0x111ff
movl -0xc(%rbp), %eax
movw %ax, -0x16(%rbp)
movq -0x8(%rbp), %rsi
movl $0x12, %edi
callq 0x10ce0
movq -0x8(%rbp), %rdx
leaq -0x16(%rbp), %rdi
movl $0x2, %esi
callq 0x10ab0
jmp 0x1121b
movq -0x8(%rbp), %rsi
movl $0x11, %edi
callq 0x10ce0
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x10ce0
jmp 0x1122f
movl -0xc(%rbp), %edi
shll $0x4, %edi
orl -0x10(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x10ce0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/./vcf.h
// Function: bcf_enc_int1
static inline void bcf_enc_int1(kstring_t *s, int32_t x)
{
	if (x == INT32_MIN) {
		bcf_enc_size(s, 1, BCF_BT_INT8);
		kputc(INT8_MIN, s);
	} else if (x <= INT8_MAX && x > INT8_MIN) {
		bcf_enc_size(s, 1, BCF_BT_INT8);
		kputc(x, s);
	} else if (x <= INT16_MAX && x > INT16_MIN) {
		int16_t z = x;
		bcf_enc_size(s, 1, BCF_BT_INT16);
		kputsn((char*)&z, 2, s);
	} else {
		int32_t z = x;
		bcf_enc_size(s, 1, BCF_BT_INT32);
		kputsn((char*)&z, 4, s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x80000000, -0xc(%rbp) # imm = 0x80000000
jne 0x1127b
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x11170
movq -0x8(%rbp), %rsi
movl $0xffffff80, %edi       # imm = 0xFFFFFF80
callq 0x10ce0
jmp 0x11314
cmpl $0x7f, -0xc(%rbp)
jg 0x112a5
cmpl $-0x80, -0xc(%rbp)
jle 0x112a5
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x11170
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x10ce0
jmp 0x11312
cmpl $0x7fff, -0xc(%rbp)     # imm = 0x7FFF
jg 0x112e5
cmpl $0xffff8000, -0xc(%rbp) # imm = 0xFFFF8000
jle 0x112e5
movl -0xc(%rbp), %eax
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x11170
movq -0x8(%rbp), %rdx
leaq -0xe(%rbp), %rdi
movl $0x2, %esi
callq 0x10ab0
jmp 0x11310
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x11170
movq -0x8(%rbp), %rdx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x10ab0
jmp 0x11312
jmp 0x11314
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/./vcf.h
// Function: bcf_dec_size
static inline int32_t bcf_dec_size(const uint8_t *p, uint8_t **q, int *type)
{
	*type = *p & 0xf;
	if (*p>>4 != 15) {
		*q = (uint8_t*)p + 1;
		return *p>>4;
	} else return bcf_dec_typed_int1(p + 1, q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
andl $0xf, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
cmpl $0xf, %eax
je 0x119e1
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
movl %eax, -0x4(%rbp)
jmp 0x119f5
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
callq 0x13b70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: align_mem
static inline void align_mem(kstring_t *s)
{
	if (s->l&7) {
		uint64_t zero = 0;
		int l = ((s->l + 7)>>3<<3) - s->l;
		kputsn((char*)&zero, l, s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x13902
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x7, %rax
shrq $0x3, %rax
shlq $0x3, %rax
movq -0x8(%rbp), %rcx
subq (%rcx), %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x10ab0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: vcf_read1
int vcf_read1(htsFile *fp, const bcf_hdr_t *h, bcf1_t *v)
{
	if (!fp->is_bin) {
		int ret;
		ret = hts_getline(fp, KS_SEP_LINE, &fp->line);
		if (ret < 0) return -1;
		ret = vcf_parse1(&fp->line, h, v);
		return 0;
	} else return bcf_read1((BGZF*)fp->fp, v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x13a6b
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
movl $0x2, %esi
callq 0x8860
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x13a4a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13a7f
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x11a00
movl %eax, -0x24(%rbp)
movl $0x0, -0x4(%rbp)
jmp 0x13a7f
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x10250
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_unpack_fmt_core
uint8_t *bcf_unpack_fmt_core(uint8_t *ptr, int n_sample, int n_fmt, bcf_fmt_t *fmt)
{
	int i;
	for (i = 0; i < n_fmt; ++i) {
		bcf_fmt_t *f = &fmt[i];
		f->id = bcf_dec_typed_int1(ptr, &ptr);
		f->n = bcf_dec_size(ptr, &ptr, &f->type);
		f->size = f->n << bcf_type_shift[f->type];
		f->p = ptr;
		ptr += n_sample * f->size;
	}
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x13b57
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x13b70
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
addq $0x8, %rdx
leaq -0x8(%rbp), %rsi
callq 0x11990
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
movslq 0x8(%rcx), %rdx
leaq 0x1a89b(%rip), %rcx     # 0x2e3b0
movzbl (%rcx,%rdx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
imull 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13aad
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_unpack_info_core
uint8_t *bcf_unpack_info_core(uint8_t *ptr, int n_info, bcf_info_t *info)
{
	int i;
	for (i = 0; i < n_info; ++i) {
		bcf_info_t *z = &info[i];
		z->key = bcf_dec_typed_int1(ptr, &ptr);
		z->len = bcf_dec_size(ptr, &ptr, &z->type);
		z->vptr = ptr;
		z->v1.i = 0;
		if (z->len == 1) {
			if (z->type == BCF_BT_INT8 || z->type == BCF_BT_CHAR) z->v1.i = *(int8_t*)ptr;
			else if (z->type == BCF_BT_INT32) z->v1.i = *(int32_t*)ptr;
			else if (z->type == BCF_BT_FLOAT) z->v1.f = *(float*)ptr;
			else if (z->type == BCF_BT_INT16) z->v1.i = *(int16_t*)ptr;
		}
		ptr += z->len << bcf_type_shift[z->type];
	}
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13cf1
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x13b70
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rsi
callq 0x11990
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x28(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x13cb7
movq -0x28(%rbp), %rax
cmpl $0x1, 0x4(%rax)
je 0x13c51
movq -0x28(%rbp), %rax
cmpl $0x7, 0x4(%rax)
jne 0x13c61
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x13cb5
movq -0x28(%rbp), %rax
cmpl $0x3, 0x4(%rax)
jne 0x13c7a
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x13cb3
movq -0x28(%rbp), %rax
cmpl $0x5, 0x4(%rax)
jne 0x13c97
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0xc(%rax)
jmp 0x13cb1
movq -0x28(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x13caf
movq -0x8(%rbp), %rax
movswl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x13cb1
jmp 0x13cb3
jmp 0x13cb5
jmp 0x13cb7
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
movslq 0x4(%rcx), %rdx
leaq 0x1a6e3(%rip), %rcx     # 0x2e3b0
movzbl (%rcx,%rdx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13bca
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/./vcf.h
// Function: bcf_dec_int1
static inline int32_t bcf_dec_int1(const uint8_t *p, int type, uint8_t **q)
{
	if (type == BCF_BT_INT8) {
		*q = (uint8_t*)p + 1;
		return *(int8_t*)p;
	} else if (type == BCF_BT_INT16) {
		*q = (uint8_t*)p + 2;
		return *(int16_t*)p;
	} else {
		*q = (uint8_t*)p + 4;
		return *(int32_t*)p;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x143f0
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x14429
cmpl $0x2, -0x14(%rbp)
jne 0x14411
movq -0x10(%rbp), %rcx
addq $0x2, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x14429
movq -0x10(%rbp), %rcx
addq $0x4, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: vcf_write1
int vcf_write1(htsFile *fp, const bcf_hdr_t *h, const bcf1_t *v)
{
	if (!fp->is_bin) {
		vcf_format1(h, v, &fp->line);
		fwrite(fp->line.s, 1, fp->line.l, (FILE*)fp->fp);
		fputc('\n', (FILE*)fp->fp);
	} else return bcf_write1((BGZF*)fp->fp, v);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x14b5d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
callq 0x14430
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %esi
callq 0x2420
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movl $0xa, %edi
callq 0x21f0
jmp 0x14b73
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x104c0
movl %eax, -0x4(%rbp)
jmp 0x14b7a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_id2int
int bcf_id2int(const bcf_hdr_t *h, int which, const char *id)
{
	khint_t k;
	vdict_t *d = (vdict_t*)h->dict[which];
	k = kh_get(vdict, d, id);
	return k == kh_end(d)? -1 : kh_val(d, k).id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13750
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x14bd9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x14bf1
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_index
hts_idx_t *bcf_index(BGZF *fp, int min_shift)
{
	int n_lvls, i;
	bcf1_t *b;
	hts_idx_t *idx;
	bcf_hdr_t *h;
	int64_t max_len = 0, s;
	h = bcf_hdr_read(fp);
	for (i = 0; i < h->n[BCF_DT_CTG]; ++i)
		if (max_len < h->id[BCF_DT_CTG][i].val->info[0])
			max_len = h->id[BCF_DT_CTG][i].val->info[0];
	max_len += 256;
	for (n_lvls = 0, s = 1<<min_shift; max_len > s; ++n_lvls, s <<= 3);
	idx = hts_idx_init(h->n[BCF_DT_CTG], HTS_FMT_CSI, bgzf_tell(fp), min_shift, n_lvls);
	bcf_hdr_destroy(h);
	b = bcf_init1();
	while (bcf_read1(fp, b) >= 0) {
		int ret;
		ret = hts_idx_push(idx, b->rid, b->pos, b->pos + b->rlen, bgzf_tell(fp), 1);
		if (ret < 0) break;
	}
	hts_idx_finish(idx, bgzf_tell(fp));
	bcf_destroy1(b);
	return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0xff80
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x14cb3
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jge 0x14ca6
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq %rax, -0x38(%rbp)
jmp 0x14ca8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14c5b
movq -0x38(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x38(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jle 0x14cfb
jmp 0x14ce4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x40(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x40(%rbp)
jmp 0x14cd8
movq -0x30(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
shlq $0x10, %rdx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cltq
orq %rax, %rdx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
xorl %esi, %esi
callq 0x9300
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0xfe40
callq 0x100d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10250
cmpl $0x0, %eax
jl 0x14da9
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
addl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %r8
shlq $0x10, %r8
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cltq
orq %rax, %r8
movl $0x1, %r9d
callq 0x9da0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jge 0x14da7
jmp 0x14da9
jmp 0x14d43
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x10, %rsi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cltq
orq %rax, %rsi
callq 0x9470
movq -0x20(%rbp), %rdi
callq 0x10100
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_index_build
int bcf_index_build(const char *fn, int min_shift)
{
	BGZF *fp;
	hts_idx_t *idx;
	if ((fp = bgzf_open(fn, "r")) == 0) return -1;
	idx = bcf_index(fp, min_shift);
	bgzf_close(fp);
	hts_idx_save(idx, fn, HTS_FMT_CSI);
	hts_idx_destroy(idx);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x132d4(%rip), %rsi     # 0x280de
callq 0x47c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x14e22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14e5a
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x14c30
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5c50
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xa6e0
movq -0x28(%rbp), %rdi
callq 0xa560
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_is_snp
int bcf_is_snp(bcf1_t *v)
{
	int i;
	bcf_unpack(v, BCF_UN_STR);
	for (i = 0; i < v->n_allele; ++i)
		if (strlen(v->d.allele[i]) != 1) break;
	return i == v->n_allele;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x13d00
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
cmpl %ecx, %eax
jge 0x152e5
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2170
cmpq $0x1, %rax
je 0x152d8
jmp 0x152e5
jmp 0x152da
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x152a1
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_is_filtered
int bcf_is_filtered(bcf1_t *b)
{
	bcf_unpack(b, BCF_UN_FLT);
	if (b->d.n_flt == 0) return 0;
	if (b->d.n_flt == 1 && b->d.flt[0] == 0) return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x13d00
movq -0x10(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x1533d
movl $0x0, -0x4(%rbp)
jmp 0x15364
movq -0x10(%rbp), %rax
cmpl $0x1, 0x5c(%rax)
jne 0x1535d
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
cmpl $0x0, (%rax)
jne 0x1535d
movl $0x0, -0x4(%rbp)
jmp 0x15364
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcfcpy
void bcfcpy(bcf1_t *dst, const bcf1_t *src)
{
	kstring_t ts = dst->shared, ti = dst->indiv;
	free(dst->d.id); free(dst->d.allele); free(dst->d.flt); free(dst->d.info); free(dst->d.fmt);
	*dst = *src;
	memset(&dst->d, 0, sizeof(bcf_dec_t));
	dst->unpacked = 0;
	dst->unpack_ptr = 0;
	ts.l = ti.l = 0;
	dst->shared = ts; dst->indiv = ti;
	kputsn(src->shared.s, src->shared.l, &dst->shared);
	kputsn(src->indiv.s, src->indiv.l, &dst->indiv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x20(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x38(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x98, %edx
callq 0x2290
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x21e0
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, %esi
movq -0x8(%rbp), %rdx
addq $0x18, %rdx
callq 0x10ab0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, %esi
movq -0x8(%rbp), %rdx
addq $0x30, %rdx
callq 0x10ab0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_get_ref_alt1
void bcf_get_ref_alt1(const bcf1_t *b, int *l_ref, char **ref, int *l_alt, char **alt)
{
	int x, type;
	uint8_t *ptr;
	*ref = *alt = 0; *l_ref = *l_alt = 0;
	ptr = (uint8_t*)b->shared.s;
	x = bcf_dec_size(ptr, &ptr, &type); // size of ID
	ptr += x << bcf_type_shift[type]; // skip ID
	x = bcf_dec_size(ptr, &ptr, &type); // size of REF
	*l_ref = x, *ref = (char*)ptr;
	ptr += x << bcf_type_shift[type]; // skip REF
	*l_alt = bcf_dec_size(ptr, &ptr, &type); // size of ALT1
	*alt = (char*)ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11990
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movslq -0x30(%rbp), %rdx
leaq 0x18e6c(%rip), %rcx     # 0x2e3b0
movzbl (%rcx,%rdx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11990
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
movslq -0x30(%rbp), %rdx
leaq 0x18e20(%rip), %rcx     # 0x2e3b0
movzbl (%rcx,%rdx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11990
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcfcmp
int bcfcmp(const bcf1_t *a, const bcf1_t *b) // FIXME: segfault when a or b is empty; also, what happens when there are not ALT alleles?
{
	int ret, l[2];
	char *ptr[2];
	if (a->rid != b->rid) return a->rid - b->rid;
	if (a->pos != b->pos) return a->pos - b->pos;
	if (a->rlen!=b->rlen) return a->rlen-b->rlen;
	ptr[0] = bcf_get_alt1(a, &l[0]);
	ptr[1] = bcf_get_alt1(b, &l[1]);
	ret = strncmp(ptr[0], ptr[1], l[0] < l[1]? l[0] : l[1]);
	if (ret != 0) return ret;
	return l[0] - l[1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x15642
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x15704
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x15668
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x15704
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x1568b
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x15704
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x155d0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
addq $0x4, %rsi
callq 0x155d0
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x156d1
movl -0x24(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x156d7
movl -0x20(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %eax
movslq %eax, %rdx
callq 0x2080
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x156fb
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15704
movl -0x24(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcfcpy_min
int bcfcpy_min(bcf1_t *b, const bcf1_t *b0, const char *alt2)
{
	int l_ref, l_alt;
	char *ref, *alt;
	bcf_get_ref_alt1(b0, &l_ref, &ref, &l_alt, &alt);
	b->rid = b0->rid, b->pos = b0->pos, b->rlen = b0->rlen;
	b->qual = 0, b->n_info = b->n_fmt = b->n_sample = 0;
	b->n_allele = alt2? 3 : 2;
	b->shared.l = b->indiv.l = 0;
	bcf_enc_size(&b->shared, 0, BCF_BT_CHAR); // empty ID
	bcf_enc_vchar(&b->shared, l_ref, ref); // copy REF
	bcf_enc_vchar(&b->shared, l_alt, alt); // copy the first ALT
	if (alt2) bcf_enc_vchar(&b->shared, strlen(alt2), alt2); // add <M> if requested
	bcf_enc_vint(&b->shared, 0, 0, -1); // empty FILTER
	b->unpacked = 0;
	return l_ref;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x154d0
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
movabsq $0xffffffffff, %rcx     # imm = 0xFFFFFFFFFF
andq 0x10(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movabsq $-0xff00000001, %rcx    # imm = 0xFFFFFF00FFFFFFFF
andq 0x10(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x10000, %rcx         # imm = 0xFFFF0000
orq $0x0, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdx
movl $0x2, %ecx
movl $0x3, %eax
cmpq $0x0, %rdx
cmovnel %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x10(%rax), %rcx
andq $0xffff, %rdx           # imm = 0xFFFF
shlq $0x10, %rdx
movabsq $-0xffff0001, %rsi      # imm = 0xFFFFFFFF0000FFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x11170
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x11360
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x20(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x11360
cmpq $0x0, -0x18(%rbp)
je 0x1587b
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2170
movq -0x38(%rbp), %rdi
movl %eax, %esi
movq -0x18(%rbp), %rdx
callq 0x11360
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10ef0
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_append_info_ints
int bcf_append_info_ints(const bcf_hdr_t *h, bcf1_t *b, const char *key, int n, const int32_t *vals)
{
	int id;
	id = bcf_id2int(h, BCF_DT_ID, key);
	if (id < 0) return -1;
	++b->n_info;
	bcf_enc_int1(&b->shared, id);
	bcf_enc_vint(&b->shared, n, vals, -1);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x14b90
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x158ec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1594b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
addl $0x1, %ecx
movl %ecx, %ecx
movl %ecx, %edx
movq 0x10(%rax), %rcx
andq $0xffff, %rdx           # imm = 0xFFFF
andq $-0x10000, %rcx         # imm = 0xFFFF0000
orq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movl -0x34(%rbp), %esi
callq 0x11240
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10ef0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/vcf.c
// Function: bcf_seekn
int bcf_seekn(BGZF *fp, const hts_idx_t *idx, int64_t r)
{
	int skip, ret = 0;
	skip = hts_idx_seekn_aux(fp, idx, r);
	if (skip > 0) {
		bcf1_t *b;
		b = bcf_init1();
		do {
			ret = bcf_read1(fp, b);
			--skip;
		} while (skip > 0 && ret >= 0);
		bcf_destroy1(b);
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc6b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x159dc
callq 0x100d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10250
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x29(%rbp)
jle 0x159cc
cmpl $0x0, -0x20(%rbp)
setge %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1599e
movq -0x28(%rbp), %rdi
callq 0x10100
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/atomic.c
// Function: bcf_atombuf_init
bcf_atombuf_t *bcf_atombuf_init(htsFile *in, int keep_flt)
{
	bcf_atombuf_t *buf;
	buf = (bcf_atombuf_t*)calloc(1, sizeof(bcf_atombuf_t));
	buf->keep_flt = !!keep_flt;
	buf->in = in;
	buf->h = vcf_hdr_read(buf->in);
	buf->b = bcf_init1();
	if (flt_read1(buf->in, buf->h, buf->b, buf->keep_flt) >= 0) {
		bcf_atomize(buf->h, buf->b, &buf->a);
		if (flt_read1(buf->in, buf->h, buf->b, buf->keep_flt) < 0)
			buf->no_vcf = 1;
	} else buf->no_vcf = 1;
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x2230
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edx
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
shll $0x10, %edx
andl $0xffff, %ecx           # imm = 0xFFFF
orl %edx, %ecx
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x105a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movb $0x0, %al
callq 0x100d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
shrl $0x10, %ecx
callq 0x17c20
cmpl $0x0, %eax
jl 0x17bf9
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
callq 0x16780
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
shrl $0x10, %ecx
callq 0x17c20
cmpl $0x0, %eax
jge 0x17bf7
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl $0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0x17c0c
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/atomic.c
// Function: flt_read1
static inline int flt_read1(htsFile *in, const bcf_hdr_t *h, bcf1_t *b, int keep_flt)
{
	int ret;
	for (;;) {
		if ((ret = vcf_read1(in, h, b)) < 0) break;
		if (keep_flt || !bcf_is_filtered(b)) break;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13a00
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jge 0x17c52
jmp 0x17c6a
cmpl $0x0, -0x1c(%rbp)
jne 0x17c66
movq -0x18(%rbp), %rdi
callq 0x15310
cmpl $0x0, %eax
jne 0x17c68
jmp 0x17c6a
jmp 0x17c37
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/atomic.c
// Function: bcf_atombuf_destroy
void bcf_atombuf_destroy(bcf_atombuf_t *buf)
{
	int i;
	for (i = 0; i < buf->a.m; ++i) {
		free(buf->a.a[i].ref.s);
		free(buf->a.a[i].gt);
	}
	free(buf->a.a);
	bcf_destroy1(buf->b);
	bcf_hdr_destroy(buf->h);
	free(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x17ce2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17c93
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10100
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xfe40
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]bgt/./atomic.h
// Function: bcf_atom_cmp
static inline int bcf_atom_cmp(const bcf_atom_t *a, const bcf_atom_t *b)
{
	if (a->rid != b->rid) return a->rid - b->rid;
	if (a->pos != b->pos) return a->pos - b->pos;
	if (a->rlen!=b->rlen) return a->rlen-b->rlen;
	return strcmp(a->alt, b->alt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
je 0x18713
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x20(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x18771
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x24(%rcx), %eax
je 0x18736
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x24(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x18771
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
je 0x18759
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x28(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x18771
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2240
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)