LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: hrec_add_idx
int hrec_add_idx(bcf_hrec_t *hrec, int idx)
{
    int n = hrec->nkeys + 1;
    char **tmp = (char**) realloc(hrec->keys, sizeof(char*)*n);
    if (!tmp) return -1;
    hrec->keys = tmp;

    tmp = (char**) realloc(hrec->vals, sizeof(char*)*n);
    if (!tmp) return -1;
    hrec->vals = tmp;

    hrec->keys[hrec->nkeys] = strdup("IDX");
    if (!hrec->keys[hrec->nkeys]) return -1;

    kstring_t str = {0,0,0};
    if (kputw(idx, &str) < 0) {
        free(hrec->keys[hrec->nkeys]);
        return -1;
    }
    hrec->vals[hrec->nkeys] = str.s;
    hrec->nkeys = n;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x18(%rbp), %rsi
shlq $0x3, %rsi
callq 0x4840
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3b9b8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3baab
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0x18(%rbp), %rsi
shlq $0x3, %rsi
callq 0x4840
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3b9f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3baab
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
leaq 0xc80f3(%rip), %rdi     # 0x103af6
callq 0x4920
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3ba3f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3baab
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4240
movl -0x14(%rbp), %edi
leaq -0x38(%rbp), %rsi
callq 0x3bac0
cmpl $0x0, %eax
jge 0x3ba82
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3baab
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
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/samtools[P]htslib/vcf.c
// Function: bcf_hrec_find_key
int bcf_hrec_find_key(bcf_hrec_t *hrec, const char *key)
{
    int i;
    for (i=0; i<hrec->nkeys; i++)
        if ( !strcasecmp(key,hrec->keys[i]) ) return i;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3bb96
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4500
cmpl $0x0, %eax
jne 0x3bb89
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3bb9d
jmp 0x3bb8b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3bb57
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_unregister_hrec
static void bcf_hdr_unregister_hrec(bcf_hdr_t *hdr, bcf_hrec_t *hrec)
{
    if (hrec->type == BCF_HL_FLT ||
        hrec->type == BCF_HL_INFO ||
        hrec->type == BCF_HL_FMT ||
        hrec->type == BCF_HL_CTG) {
        int id = bcf_hrec_find_key(hrec, "ID");
        if (id < 0 || !hrec->vals[id])
            return;
        vdict_t *dict = (hrec->type == BCF_HL_CTG
                         ? (vdict_t*)hdr->dict[BCF_DT_CTG]
                         : (vdict_t*)hdr->dict[BCF_DT_ID]);
        khint_t k = kh_get(vdict, dict, hrec->vals[id]);
        if (k != kh_end(dict))
            kh_val(dict, k).hrec[hrec->type==BCF_HL_CTG ? 0 : hrec->type] = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3e088
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x3e088
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x3e088
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x3e152
movq -0x10(%rbp), %rdi
leaq 0xc7f05(%rip), %rsi     # 0x105f98
callq 0x3bb40
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x3e0b4
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3e0b9
jmp 0x3e152
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x3e0d0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x3e0dc
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3e520
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x3e150
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x24(%rbp), %ecx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x3e135
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3e13e
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x3e152
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_check_sanity
void bcf_hdr_check_sanity(bcf_hdr_t *hdr)
{
    static int PL_warned = 0, GL_warned = 0;

    if ( !PL_warned )
    {
        int id = bcf_hdr_id2int(hdr, BCF_DT_ID, "PL");
        if ( bcf_hdr_idinfo_exists(hdr,BCF_HL_FMT,id) && bcf_hdr_id2length(hdr,BCF_HL_FMT,id)!=BCF_VL_G )
        {
            hts_log_warning("PL should be declared as Number=G");
            PL_warned = 1;
        }
    }
    if ( !GL_warned )
    {
        int id = bcf_hdr_id2int(hdr, BCF_DT_ID, "GL");
        if ( bcf_hdr_idinfo_exists(hdr,BCF_HL_FMT,id) && bcf_hdr_id2length(hdr,BCF_HL_FMT,id)!=BCF_VL_G )
        {
            hts_log_warning("GL should be declared as Number=G");
            GL_warned = 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xec11d(%rip)     # 0x12a7a0
jne 0x3e744
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0xc9169(%rip), %rdx     # 0x1077ff
callq 0x3e820
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x3e742
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3e742
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x3e742
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
andq $0xf, %rax
cmpl $0xf, %eax
je 0x3e742
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
shrq $0x8, %rax
andq $0xf, %rax
cmpq $0x3, %rax
je 0x3e742
movl $0x3, %edi
leaq 0xc90d8(%rip), %rsi     # 0x107802
leaq 0xc90e6(%rip), %rdx     # 0x107817
movb $0x0, %al
callq 0x9d90
movl $0x1, 0xec05e(%rip)     # 0x12a7a0
jmp 0x3e744
cmpl $0x0, 0xec059(%rip)     # 0x12a7a4
jne 0x3e80c
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0xc90db(%rip), %rdx     # 0x107839
callq 0x3e820
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x3e80a
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3e80a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x3e80a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
andq $0xf, %rax
cmpl $0xf, %eax
je 0x3e80a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
shrq $0x8, %rax
andq $0xf, %rax
cmpq $0x3, %rax
je 0x3e80a
movl $0x3, %edi
leaq 0xc9010(%rip), %rsi     # 0x107802
leaq 0xc9043(%rip), %rdx     # 0x10783c
movb $0x0, %al
callq 0x9d90
movl $0x1, 0xebf9a(%rip)     # 0x12a7a4
jmp 0x3e80c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_id2int
int bcf_hdr_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 0x28(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3e520
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x3e869
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x3e881
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl 0x30(%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/samtools[P]htslib/vcf.c
// Function: bcf_hdr_append
int bcf_hdr_append(bcf_hdr_t *hdr, const char *line)
{
    int len;
    bcf_hrec_t *hrec = bcf_hdr_parse_line(hdr, (char*) line, &len);
    if ( !hrec ) return -1;
    if (bcf_hdr_add_hrec(hdr, hrec) < 0)
        return -1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x3bbb0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3ec25
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3ec47
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3ce30
cmpl $0x0, %eax
jge 0x3ec40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3ec47
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_printf
int bcf_hdr_printf(bcf_hdr_t *hdr, const char *fmt, ...)
{
    char tmp[256], *line = tmp;
    va_list ap;
    va_start(ap, fmt);
    int n = vsnprintf(line, sizeof(tmp), fmt, ap);
    va_end(ap);

    if (n >= sizeof(tmp)) {
        n++; // For trailing NUL
        line = (char*)malloc(n);
        if (!line)
            return -1;

        va_start(ap, fmt);
        vsnprintf(line, n, fmt, ap);
        va_end(ap);
    }

    int ret = bcf_hdr_append(hdr, line);

    if (line != tmp) free(line);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
testb %al, %al
je 0x3f237
movaps %xmm0, -0x1d0(%rbp)
movaps %xmm1, -0x1c0(%rbp)
movaps %xmm2, -0x1b0(%rbp)
movaps %xmm3, -0x1a0(%rbp)
movaps %xmm4, -0x190(%rbp)
movaps %xmm5, -0x180(%rbp)
movaps %xmm6, -0x170(%rbp)
movaps %xmm7, -0x160(%rbp)
movq %r9, -0x1d8(%rbp)
movq %r8, -0x1e0(%rbp)
movq %rcx, -0x1e8(%rbp)
movq %rdx, -0x1f0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x140(%rbp), %rax
leaq -0x200(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x128(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x140(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x42b0
movl %eax, -0x144(%rbp)
leaq -0x140(%rbp), %rax
movslq -0x144(%rbp), %rax
cmpq $0x100, %rax            # imm = 0x100
jb 0x3f350
movl -0x144(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
movslq -0x144(%rbp), %rdi
callq 0x4670
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x128(%rbp)
jne 0x3f304
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f38e
leaq -0x140(%rbp), %rax
leaq -0x200(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x128(%rbp), %rdi
movslq -0x144(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x140(%rbp), %rcx
callq 0x42b0
leaq -0x140(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0x3ebf0
movl %eax, -0x148(%rbp)
movq -0x128(%rbp), %rax
leaq -0x120(%rbp), %rcx
cmpq %rcx, %rax
je 0x3f385
movq -0x128(%rbp), %rdi
callq 0x45a0
movl -0x148(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_get_version
const char *bcf_hdr_get_version(const bcf_hdr_t *hdr)
{
    bcf_hrec_t *hrec = bcf_hdr_get_hrec(hdr, BCF_HL_GEN, "fileformat", NULL, NULL);
    if ( !hrec )
    {
        hts_log_warning("No version string found, assuming VCFv4.2");
        return "VCFv4.2";
    }
    return hrec->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x5, %esi
leaq 0xc841e(%rip), %rdx     # 0x1077da
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x3e160
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3f3fb
movl $0x3, %edi
leaq 0xc85d4(%rip), %rsi     # 0x1079b4
leaq 0xc85e1(%rip), %rdx     # 0x1079c8
movb $0x0, %al
callq 0x9d90
leaq 0xc85f5(%rip), %rax     # 0x1079ea
movq %rax, -0x8(%rbp)
jmp 0x3f407
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_set_version
int bcf_hdr_set_version(bcf_hdr_t *hdr, const char *version)
{
    bcf_hrec_t *hrec = bcf_hdr_get_hrec(hdr, BCF_HL_GEN, "fileformat", NULL, NULL);
    if ( !hrec )
    {
        int len;
        kstring_t str = {0,0,0};
        if ( ksprintf(&str,"##fileformat=%s", version) < 0 ) return -1;
        hrec = bcf_hdr_parse_line(hdr, str.s, &len);
        free(str.s);

        get_hdr_aux(hdr)->version = bcf_get_version(NULL, hrec->value);
    }
    else
    {
        bcf_hrec_t *tmp = bcf_hrec_dup(hrec);
        if ( !tmp ) return -1;
        free(tmp->value);
        tmp->value = strdup(version);
        if ( !tmp->value ) return -1;
        bcf_hdr_update_hrec(hdr, hrec, tmp);
        bcf_hrec_destroy(tmp);
    }
    hdr->dirty = 1;
    //TODO rlen may change, deal with it
    return 0; // FIXME: check for errs in this function (return < 0 if so)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x5, %esi
leaq 0xc839a(%rip), %rdx     # 0x1077da
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x3e160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3f4d2
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4240
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq 0xc857b(%rip), %rsi     # 0x1079f2
movb $0x0, %al
callq 0xd62e0
cmpl $0x0, %eax
jge 0x3f48f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f550
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x3bbb0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x45a0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x3cc20
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b020
movl -0x4c(%rbp), %ecx
movl %ecx, 0x38(%rax)
jmp 0x3f53e
movq -0x20(%rbp), %rdi
callq 0x3b0f0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x3f4ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f550
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x45a0
movq -0x18(%rbp), %rdi
callq 0x4920
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3f524
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f550
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x3c610
movq -0x48(%rbp), %rdi
callq 0x3b040
movq -0x10(%rbp), %rax
movl $0x1, 0x54(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_write
int bcf_hdr_write(htsFile *hfp, bcf_hdr_t *h)
{
    if (!h) {
        errno = EINVAL;
        return -1;
    }
    if ( h->dirty ) {
        if (bcf_hdr_sync(h) < 0) return -1;
    }
    hfp->format.category = variant_data;
    if (hfp->format.format == vcf || hfp->format.format == text_format) {
        hfp->format.format = vcf;
        return vcf_hdr_write(hfp, h);
    }

    if (hfp->format.format == binary_format)
        hfp->format.format = bcf;

    kstring_t htxt = {0,0,0};
    if (bcf_hdr_format(h, 1, &htxt) < 0) {
        free(htxt.s);
        return -1;
    }
    kputc('\0', &htxt); // include the \0 byte

    BGZF *fp = hfp->fp.bgzf;
    if ( bgzf_write(fp, "BCF\2\2", 5) !=5 ) return -1;
    uint8_t hlen[4];
    u32_to_le(htxt.l, hlen);
    if ( bgzf_write(fp, hlen, 4) !=4 ) return -1;
    if ( bgzf_write(fp, htxt.s, htxt.l) != htxt.l ) return -1;
    if ( bgzf_flush(fp) < 0) return -1;

    free(htxt.s);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4073e
callq 0x4050
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x408a6
movq -0x18(%rbp), %rax
cmpl $0x0, 0x54(%rax)
je 0x40764
movq -0x18(%rbp), %rdi
callq 0x3ae50
cmpl $0x0, %eax
jge 0x40762
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x408a6
jmp 0x40764
movq -0x10(%rbp), %rax
movl $0x2, 0x48(%rax)
movq -0x10(%rbp), %rax
cmpl $0x8, 0x4c(%rax)
je 0x40783
movq -0x10(%rbp), %rax
cmpl $0x2, 0x4c(%rax)
jne 0x407a3
movq -0x10(%rbp), %rax
movl $0x8, 0x4c(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x408b0
movl %eax, -0x4(%rbp)
jmp 0x408a6
movq -0x10(%rbp), %rax
cmpl $0x1, 0x4c(%rax)
jne 0x407b8
movq -0x10(%rbp), %rax
movl $0x9, 0x4c(%rax)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4240
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq -0x30(%rbp), %rdx
callq 0x409c0
cmpl $0x0, %eax
jge 0x407f4
movq -0x20(%rbp), %rdi
callq 0x45a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x408a6
xorl %edi, %edi
leaq -0x30(%rbp), %rsi
callq 0x40b10
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0xc72bd(%rip), %rsi     # 0x107ad3
movl $0x5, %edx
callq 0xdb250
cmpq $0x5, %rax
je 0x4082f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x408a6
movq -0x30(%rbp), %rax
movl %eax, %edi
leaq -0x3c(%rbp), %rsi
callq 0x40b90
movq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
movl $0x4, %edx
callq 0xdb250
cmpq $0x4, %rax
je 0x4085f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x408a6
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xdb250
cmpq -0x30(%rbp), %rax
je 0x4087f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x408a6
movq -0x38(%rbp), %rdi
callq 0xdaac0
cmpl $0x0, %eax
jge 0x40896
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x408a6
movq -0x20(%rbp), %rdi
callq 0x45a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: vcf_hdr_write
int vcf_hdr_write(htsFile *fp, const bcf_hdr_t *h)
{
    kstring_t htxt = {0,0,0};
    if (bcf_hdr_format(h, 0, &htxt) < 0) {
        free(htxt.s);
        return -1;
    }
    while (htxt.l && htxt.s[htxt.l-1] == '\0') --htxt.l; // kill trailing zeros
    int ret;
    if ( fp->format.compression!=no_compression ) {
        ret = bgzf_write(fp->fp.bgzf, htxt.s, htxt.l);
        if (bgzf_flush(fp->fp.bgzf) != 0) return -1;
    } else {
        ret = hwrite(fp->fp.hfile, htxt.s, htxt.l);
    }
    free(htxt.s);
    return ret<0 ? -1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4240
movq -0x18(%rbp), %rdi
xorl %esi, %esi
leaq -0x30(%rbp), %rdx
callq 0x409c0
cmpl $0x0, %eax
jge 0x408f9
movq -0x20(%rbp), %rdi
callq 0x45a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x409aa
jmp 0x408fb
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x35(%rbp)
je 0x40920
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x40929
jmp 0x40937
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x408fb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x54(%rax)
je 0x40976
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xdb250
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xdaac0
cmpl $0x0, %eax
je 0x40974
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x409aa
jmp 0x4098e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x441b0
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
callq 0x45a0
movl -0x34(%rbp), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_format
int bcf_hdr_format(const bcf_hdr_t *hdr, int is_bcf, kstring_t *str)
{
    int i, r = 0;
    for (i=0; i<hdr->nhrec; i++)
        r |= _bcf_hrec_format(hdr->hrec[i], is_bcf, str) < 0;

    r |= ksprintf(str, "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO") < 0;
    if ( bcf_hdr_nsamples(hdr) )
    {
        r |= ksprintf(str, "\tFORMAT") < 0;
        for (i=0; i<bcf_hdr_nsamples(hdr); i++)
            r |= ksprintf(str, "\t%s", hdr->samples[i]) < 0;
    }
    r |= ksprintf(str, "\n") < 0;

    return r ? -1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x40a25
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x43d40
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x409e1
movq -0x18(%rbp), %rdi
leaq 0xc6ab0(%rip), %rsi     # 0x1074e0
movb $0x0, %al
callq 0xd62e0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x40ac8
movq -0x18(%rbp), %rdi
leaq 0xc723d(%rip), %rsi     # 0x107c9a
movb $0x0, %al
callq 0xd62e0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x40ac6
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xc6b5c(%rip), %rsi     # 0x1075ff
movb $0x0, %al
callq 0xd62e0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40a7c
jmp 0x40ac8
movq -0x18(%rbp), %rdi
leaq 0xc3fe0(%rip), %rsi     # 0x104ab3
movb $0x0, %al
callq 0xd62e0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_empty
void bcf_empty(bcf1_t *v)
{
    bcf_clear1(v);
    free(v->d.id);
    free(v->d.als);
    free(v->d.allele); free(v->d.flt); free(v->d.info); free(v->d.fmt);
    if (v->d.var ) free(v->d.var);
    free(v->shared.s); free(v->indiv.s);
    memset(&v->d,0,sizeof(v->d));
    memset(&v->shared,0,sizeof(v->shared));
    memset(&v->indiv,0,sizeof(v->indiv));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40be0
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x40f3d
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x4240
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4240
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_unpack_fmt_core1
static inline uint8_t *bcf_unpack_fmt_core1(uint8_t *ptr, int n_sample, bcf_fmt_t *fmt)
{
    uint8_t *ptr_start = ptr;
    fmt->id = bcf_dec_typed_int1(ptr, &ptr);
    fmt->n = bcf_dec_size(ptr, &ptr, &fmt->type);
    fmt->size = fmt->n << bcf_type_shift[fmt->type];
    fmt->p = ptr;
    fmt->p_off  = ptr - ptr_start;
    fmt->p_free = 0;
    ptr += n_sample * fmt->size;
    fmt->p_len = ptr - fmt->p;
    return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x49e70
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0xc, %rdx
leaq -0x8(%rbp), %rsi
callq 0x454d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movslq 0xc(%rcx), %rdx
leaq 0xe414c(%rip), %rcx     # 0x125650
movzbl (%rcx,%rdx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl $0x80000000, %ecx       # imm = 0x80000000
orl %edx, %ecx
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x1c(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
imull 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_read
int bcf_read(htsFile *fp, const bcf_hdr_t *h, bcf1_t *v)
{
    if (fp->format.format == vcf) return vcf_read(fp,h,v);
    int ret = bcf_read1_core(fp->fp.bgzf, v);
    if (ret == 0) ret = bcf_record_check(h, v);
    if ( ret!=0 || !h->keep_samples ) return ret;
    return bcf_subset_format(h,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
cmpl $0x8, 0x4c(%rax)
jne 0x415d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x41630
movl %eax, -0x4(%rbp)
jmp 0x41627
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x41690
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x415fe
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x419d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x4160f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x41617
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x41627
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x40fd0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_readrec
int bcf_readrec(BGZF *fp, void *null, void *vv, int *tid, hts_pos_t *beg, hts_pos_t *end)
{
    bcf1_t *v = (bcf1_t *) vv;
    int ret = bcf_read1_core(fp, v);
    if (ret == 0) ret = bcf_record_check(NULL, v);
    if (ret  >= 0)
        *tid = v->rid, *beg = v->pos, *end = v->pos + v->rlen;
    return ret;
}

// 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 %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x41690
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x4248e
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x419d0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0x424c5
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
addq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_strerror
const char *bcf_strerror(int errorcode, char *buffer, size_t maxbuffer) {
    size_t usedup = 0;
    int ret = 0;
    int idx;

    if (!buffer || maxbuffer < 4)
        return NULL;           //invalid / insufficient buffer

    if (!errorcode) {
        buffer[0] = '\0';      //no error, set null
        return buffer;
    }

    for (idx = 0; idx < sizeof(errdesc_bcf) / sizeof(err_desc); ++idx) {
        if (errorcode & errdesc_bcf[idx].errorcode) {    //error is set, add description
            ret = add_desc_to_buffer(buffer, &usedup, maxbuffer, errdesc_bcf[idx].description);
            if (ret < 0)
                break;         //not enough space, ... added, no need to continue

            errorcode &= ~errdesc_bcf[idx].errorcode;    //reset the error
        }
    }

    if (errorcode && (ret >= 0))  {     //undescribed error is present in error code and had enough buffer, try to add unkonwn error as well§
        add_desc_to_buffer(buffer, &usedup, maxbuffer, "Unknown error");
    }
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x437a0
cmpq $0x4, -0x20(%rbp)
jae 0x437ad
movq $0x0, -0x8(%rbp)
jmp 0x4387f
cmpl $0x0, -0xc(%rbp)
jne 0x437c7
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4387f
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
cmpq $0x7, %rax
jae 0x43853
movl -0xc(%rbp), %eax
movslq -0x30(%rbp), %rdx
leaq 0xe135a(%rip), %rcx     # 0x124b40
shlq $0x4, %rdx
addq %rdx, %rcx
andl (%rcx), %eax
cmpl $0x0, %eax
je 0x43843
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movslq -0x30(%rbp), %rcx
leaq 0xe1339(%rip), %rax     # 0x124b40
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
leaq -0x28(%rbp), %rsi
callq 0x51330
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x43826
jmp 0x43853
movslq -0x30(%rbp), %rcx
leaq 0xe130f(%rip), %rax     # 0x124b40
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
xorl $-0x1, %eax
andl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x43845
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x437ce
cmpl $0x0, -0xc(%rbp)
je 0x43877
cmpl $0x0, -0x2c(%rbp)
jl 0x43877
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rsi
leaq 0xc4c79(%rip), %rcx     # 0x1084eb
callq 0x51330
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: add_missing_contig_hrec
static int add_missing_contig_hrec(bcf_hdr_t *h, const char *name) {
    bcf_hrec_t *hrec = calloc(1, sizeof(bcf_hrec_t));
    int save_errno;
    if (!hrec) goto fail;

    hrec->key = strdup("contig");
    if (!hrec->key) goto fail;

    if (bcf_hrec_add_key(hrec, "ID", strlen("ID")) < 0) goto fail;
    if (bcf_hrec_set_val(hrec, hrec->nkeys-1, name, strlen(name), 0) < 0)
        goto fail;
    if (bcf_hdr_add_hrec(h, hrec) < 0)
        goto fail;
    return 0;

 fail:
    save_errno = errno;
    hts_log_error("%s", strerror(errno));
    if (hrec) bcf_hrec_destroy(hrec);
    errno = save_errno;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x42e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x43a7f
jmp 0x43b1f
leaq 0xc56d7(%rip), %rdi     # 0x10915d
callq 0x4920
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x43aa3
jmp 0x43b1f
movq -0x20(%rbp), %rdi
leaq 0xc24ea(%rip), %rsi     # 0x105f98
movl $0x2, %edx
callq 0x3b610
cmpl $0x0, %eax
jge 0x43abf
jmp 0x43b1f
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41a0
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x3b790
cmpl $0x0, %eax
jge 0x43b02
jmp 0x43b1f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3ce30
cmpl $0x0, %eax
jge 0x43b16
jmp 0x43b1f
movl $0x0, -0x4(%rbp)
jmp 0x43b79
callq 0x4050
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq %rax, %rcx
movl $0x1, %edi
leaq 0xc4ea5(%rip), %rsi     # 0x1089e9
leaq 0xc3ab5(%rip), %rdx     # 0x107600
movb $0x0, %al
callq 0x9d90
cmpq $0x0, -0x20(%rbp)
je 0x43b62
movq -0x20(%rbp), %rdi
callq 0x3b040
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0x4050
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_set
int bcf_hdr_set(bcf_hdr_t *hdr, const char *fname)
{
    int i = 0, n = 0, save_errno;
    char **lines = hts_readlines(fname, &n);
    if ( !lines ) return 1;
    for (i=0; i<n-1; i++)
    {
        int k;
        bcf_hrec_t *hrec = bcf_hdr_parse_line(hdr,lines[i],&k);
        if (!hrec) goto fail;
        if (bcf_hdr_add_hrec(hdr, hrec) < 0) {
            bcf_hrec_destroy(hrec);
            goto fail;
        }
        free(lines[i]);
        lines[i] = NULL;
    }
    if (bcf_hdr_parse_sample_line(hdr, lines[n-1]) < 0) goto fail;
    if (bcf_hdr_sync(hdr) < 0) goto fail;
    free(lines[n-1]);
    free(lines);
    return 0;

 fail:
    save_errno = errno;
    for (; i < n; i++)
        free(lines[i]);
    free(lines);
    errno = save_errno;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd4e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x43bd2
movl $0x1, -0x4(%rbp)
jmp 0x43d05
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x43c5e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x34(%rbp), %rdx
callq 0x3bbb0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x43c0f
jmp 0x43cb7
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3ce30
cmpl $0x0, %eax
jge 0x43c2f
movq -0x40(%rbp), %rdi
callq 0x3b040
jmp 0x43cb7
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x43bd9
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3ac80
cmpl $0x0, %eax
jge 0x43c7f
jmp 0x43cb7
movq -0x10(%rbp), %rdi
callq 0x3ae50
cmpl $0x0, %eax
jge 0x43c8f
jmp 0x43cb7
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
movq -0x30(%rbp), %rdi
callq 0x45a0
movl $0x0, -0x4(%rbp)
jmp 0x43d05
callq 0x4050
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x43ce5
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x43cc1
movq -0x30(%rbp), %rdi
callq 0x45a0
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0x4050
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hrec_format
static int _bcf_hrec_format(const bcf_hrec_t *hrec, int is_bcf, kstring_t *str)
{
    uint32_t e = 0;
    if ( !hrec->value )
    {
        int j, nout = 0;
        e |= ksprintf(str, "##%s=<", hrec->key) < 0;
        for (j=0; j<hrec->nkeys; j++)
        {
            // do not output IDX if output is VCF
            if ( !is_bcf && !strcmp("IDX",hrec->keys[j]) ) continue;
            if ( nout ) e |= kputc(',',str) < 0;
            e |= ksprintf(str,"%s=%s", hrec->keys[j], hrec->vals[j]) < 0;
            nout++;
        }
        e |= ksprintf(str,">\n") < 0;
    }
    else
        e |= ksprintf(str,"##%s=%s\n", hrec->key,hrec->value) < 0;

    return e == 0 ? 0 : -1;
}

// 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)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x43e7f
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xc38ac(%rip), %rsi     # 0x10762f
movb $0x0, %al
callq 0xd62e0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x43e5a
cmpl $0x0, -0xc(%rbp)
jne 0x43ddb
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xbfd27(%rip), %rdi     # 0x103af6
callq 0x46b0
cmpl $0x0, %eax
jne 0x43ddb
jmp 0x43e4c
cmpl $0x0, -0x24(%rbp)
je 0x43e00
movq -0x18(%rbp), %rsi
movl $0x2c, %edi
callq 0x40b10
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xc39a9(%rip), %rsi     # 0x1077d4
movb $0x0, %al
callq 0xd62e0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x43da2
movq -0x18(%rbp), %rdi
leaq 0xc37d8(%rip), %rsi     # 0x10763d
movb $0x0, %al
callq 0xd62e0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x43eb2
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xc37a6(%rip), %rsi     # 0x107640
movb $0x0, %al
callq 0xd62e0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hdr_fmt_text
char *bcf_hdr_fmt_text(const bcf_hdr_t *hdr, int is_bcf, int *len)
{
    kstring_t txt = {0,0,0};
    if (bcf_hdr_format(hdr, is_bcf, &txt) < 0)
        return NULL;
    if ( len ) *len = txt.l;
    return txt.s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4240
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0x409c0
cmpl $0x0, %eax
jge 0x43f12
movq $0x0, -0x8(%rbp)
jmp 0x43f2d
cmpq $0x0, -0x20(%rbp)
je 0x43f25
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/vcf.h
// Function: bcf_enc_size
static inline int bcf_enc_size(kstring_t *s, int size, int type)
{
    // Most common case is first
    if (size < 15) {
        if (ks_resize(s, s->l + 1) < 0)
            return -1;
        uint8_t *p = (uint8_t *)s->s + s->l;
        *p++ = (size<<4) | type;
        s->l++;
        return 0;
    }

    if (ks_resize(s, s->l + 6) < 0)
        return -1;
    uint8_t *p = (uint8_t *)s->s + s->l;
    *p++ = 15<<4|type;

    if (size < 128) {
        *p++ = 1<<4|BCF_BT_INT8;
        *p++ = size;
        s->l += 3;
    } else {
        if (size < 32768) {
            *p++ = 1<<4|BCF_BT_INT16;
            i16_to_le(size, p);
            s->l += 4;
        } else {
            *p++ = 1<<4|BCF_BT_INT32;
            i32_to_le(size, p);
            s->l += 6;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0xf, -0x14(%rbp)
jge 0x44936
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x1, %rsi
callq 0x44ba0
cmpl $0x0, %eax
jge 0x448ed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44a39
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
shll $0x4, %eax
orl -0x18(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x44a39
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x6, %rsi
callq 0x44ba0
cmpl $0x0, %eax
jge 0x4495b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44a39
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
orl $0xf0, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
cmpl $0x80, -0x14(%rbp)
jge 0x449ca
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x11, (%rax)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
jmp 0x44a32
cmpl $0x8000, -0x14(%rbp)    # imm = 0x8000
jge 0x44a04
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x12, (%rax)
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rsi
movswl %ax, %edi
callq 0x44c40
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
jmp 0x44a30
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x13, (%rax)
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x43890
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x6, %rcx
movq %rcx, (%rax)
jmp 0x44a32
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/samtools[P]htslib/./htslib/vcf.h
// Function: bcf_enc_int1
static inline int bcf_enc_int1(kstring_t *s, int32_t x)
{
    if (ks_resize(s, s->l + 5) < 0)
        return -1;
    uint8_t *p = (uint8_t *)s->s + s->l;

    if (x == bcf_int32_vector_end) {
        // An inline implementation of bcf_enc_size with size==1 and
        // memory allocation already accounted for.
        *p = (1<<4) | BCF_BT_INT8;
        p[1] = bcf_int8_vector_end;
        s->l+=2;
    } else if (x == bcf_int32_missing) {
        *p = (1<<4) | BCF_BT_INT8;
        p[1] = bcf_int8_missing;
        s->l+=2;
    } else if (x <= BCF_MAX_BT_INT8 && x >= BCF_MIN_BT_INT8) {
        *p = (1<<4) | BCF_BT_INT8;
        p[1] = x;
        s->l+=2;
    } else if (x <= BCF_MAX_BT_INT16 && x >= BCF_MIN_BT_INT16) {
        *p = (1<<4) | BCF_BT_INT16;
        i16_to_le(x, p+1);
        s->l+=3;
    } else {
        *p = (1<<4) | BCF_BT_INT32;
        i32_to_le(x, p+1);
        s->l+=5;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x5, %rsi
callq 0x44ba0
cmpl $0x0, %eax
jge 0x44a84
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44b8a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
cmpl $0x80000001, -0x14(%rbp) # imm = 0x80000001
jne 0x44ac2
movq -0x20(%rbp), %rax
movb $0x11, (%rax)
movq -0x20(%rbp), %rax
movb $-0x7f, 0x1(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x44b83
cmpl $0x80000000, -0x14(%rbp) # imm = 0x80000000
jne 0x44aed
movq -0x20(%rbp), %rax
movb $0x11, (%rax)
movq -0x20(%rbp), %rax
movb $-0x80, 0x1(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x44b81
cmpl $0x7f, -0x14(%rbp)
jg 0x44b1c
cmpl $-0x78, -0x14(%rbp)
jl 0x44b1c
movq -0x20(%rbp), %rax
movb $0x11, (%rax)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x44b7f
cmpl $0x7fff, -0x14(%rbp)    # imm = 0x7FFF
jg 0x44b58
cmpl $0xffff8008, -0x14(%rbp) # imm = 0xFFFF8008
jl 0x44b58
movq -0x20(%rbp), %rax
movb $0x12, (%rax)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movswl %ax, %edi
callq 0x44c40
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
jmp 0x44b7d
movq -0x20(%rbp), %rax
movb $0x13, (%rax)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x43890
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x5, %rcx
movq %rcx, (%rax)
jmp 0x44b7f
jmp 0x44b81
jmp 0x44b83
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/samtools[P]htslib/vcf.c
// Function: bcf_enc_vfloat
int bcf_enc_vfloat(kstring_t *s, int n, float *a)
{
    assert(n >= 0);
    bcf_enc_size(s, n, BCF_BT_FLOAT);
    serialize_float_array(s, n, a);
    return 0; // FIXME: check for errs in this function
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x44c8b
jmp 0x44caa
leaq 0xc303b(%rip), %rdi     # 0x107ccd
leaq 0xc29ca(%rip), %rsi     # 0x107663
movl $0xaa4, %edx            # imm = 0xAA4
leaq 0xc302f(%rip), %rcx     # 0x107cd4
callq 0x42d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x5, %edx
callq 0x448b0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x44ce0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)