LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/vcf.c
// Function: bcf_get_version
static int bcf_get_version(const bcf_hdr_t *hdr, const char *verstr)
{
    const char *version = NULL, vcf[] = "VCFv";
    char *major = NULL, *minor = NULL;
    int ver = -1;
    long tmp = 0;
    bcf_hdr_aux_t *aux = NULL;

    if (!hdr && !verstr) {  //invalid input
        goto fail;
    }

    if (hdr) {
        if ((aux = get_hdr_aux(hdr)) && aux->version != 0) {    //use cached version
            return aux->version;
        }
        //get from header
        version = bcf_hdr_get_version(hdr);
    } else {
        //get from version string
        version = verstr;
    }
    if (!(major = strstr(version, vcf))) {  //bad format
        goto fail;
    }
    major += sizeof(vcf) - 1;
    if (!(minor = strchr(major, '.'))) {    //bad format
        goto fail;
    }
    tmp = strtol(major, NULL, 10);
    if ((!tmp && errno == EINVAL) ||
        ((tmp == LONG_MIN || tmp == LONG_MAX) && errno == ERANGE)) {    //failed
        goto fail;
    }
    ver = tmp * 100 * 10000;
    tmp = strtol(++minor, NULL, 10);
    if ((!tmp && errno == EINVAL) ||
        ((tmp == LONG_MIN || tmp == LONG_MAX) && errno == ERANGE)) {    //failed
        goto fail;
    }
    ver += tmp * 1000;
    return ver;

fail:
    hts_log_warning("Couldn't get VCF version, considering as %d.%d",
        VCF_MAJOR_VER(VCF_DEF), VCF_MINOR_VER(VCF_DEF));
    return VCF_DEF;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
orq %rsi, %rax
je 0x2bd63
testq %rdi, %rdi
je 0x2bc93
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x2bc8b
movl 0x38(%rax), %ebx
testl %ebx, %ebx
jne 0x2bd8d
callq 0x2de43
movq %rax, %rsi
leaq 0x80812(%rip), %rax     # 0xac4ac
movq %rsi, %rdi
movq %rax, %rsi
callq 0x40d0
testq %rax, %rax
je 0x2bd63
movq %rax, %rbx
addq $0x4, %rbx
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x4180
testq %rax, %rax
je 0x2bd63
movq %rax, %r14
movabsq $-0x7fffffffffffffff, %r15 # imm = 0x8000000000000001
movq %rbx, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x46f0
movq %rax, %rbx
testq %rax, %rax
je 0x2bd05
leaq (%rbx,%r15), %rax
cmpq $0x1, %rax
ja 0x2bd0f
callq 0x4050
cmpl $0x22, (%rax)
jne 0x2bd0f
jmp 0x2bd63
callq 0x4050
cmpl $0x16, (%rax)
je 0x2bd63
incq %r14
movq %r14, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x46f0
movq %rax, %r14
testq %rax, %rax
je 0x2bd59
addq %r14, %r15
cmpq $0x1, %r15
ja 0x2bd3c
callq 0x4050
cmpl $0x22, (%rax)
je 0x2bd63
imull $0x3e8, %r14d, %eax     # imm = 0x3E8
movabsq $0xf424000000000, %rcx  # imm = 0xF424000000000
imulq %rcx, %rbx
shrq $0x20, %rbx
addl %eax, %ebx
jmp 0x2bd8d
callq 0x4050
cmpl $0x16, (%rax)
jne 0x2bd3c
leaq 0x80747(%rip), %rsi     # 0xac4b1
leaq 0x80750(%rip), %rdx     # 0xac4c1
movl $0x3, %edi
movl $0x4, %ecx
movl $0x2, %r8d
xorl %eax, %eax
callq 0x942d
movl $0x3d10d0, %ebx         # imm = 0x3D10D0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl (%rsi), %eax
movl %eax, 0x4(%rsp)
cmpl $0x3, %eax
ja 0x2ce42
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7cff2(%rip), %rsi     # 0xa9d0a
movq %rbx, %rdi
callq 0x2b32b
testl %eax, %eax
js 0x2ce42
movq 0x28(%rbx), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rbx
testq %rbx, %rbx
je 0x2ce42
xorl %eax, %eax
cmpl $0x3, 0x4(%rsp)
sete %al
movq 0x28(%r14,%rax,8), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
testl %eax, %eax
je 0x2cd85
movq %rax, 0x18(%rsp)
leal -0x1(%rax), %edx
movb (%rbx), %cl
testb %cl, %cl
je 0x2cd8d
leaq 0x1(%rbx), %rax
movl $0x811c9dc5, %r12d      # imm = 0x811C9DC5
movzbl %cl, %ecx
xorl %r12d, %ecx
imull $0x1000193, %ecx, %r12d # imm = 0x1000193
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x2cd6d
jmp 0x2cd93
xorl %r14d, %r14d
jmp 0x2ce18
movl $0x811c9dc5, %r12d      # imm = 0x811C9DC5
andl %edx, %r12d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movl $0x1, %r15d
movl %r12d, %r14d
movl %edx, 0x14(%rsp)
movq %rsi, 0x20(%rsp)
movl %r14d, %eax
shrl $0x4, %eax
movl (%rsi,%rax,4), %r13d
leal (%r14,%r14), %ebp
andl $0x1e, %ebp
movl %r13d, %eax
movl %ebp, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x2ce06
testb $0x1, %al
jne 0x2cdf6
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl %r14d, %ecx
movq (%rax,%rcx,8), %rdi
movq %rbx, %rsi
callq 0x46e0
movq 0x20(%rsp), %rsi
movl 0x14(%rsp), %edx
testl %eax, %eax
je 0x2ce06
addl %r15d, %r14d
andl %edx, %r14d
incl %r15d
cmpl %r12d, %r14d
jne 0x2cdb1
jmp 0x2ce42
movl %ebp, %ecx
shrl %cl, %r13d
testb $0x3, %r13b
movq 0x18(%rsp), %rax
cmovnel %eax, %r14d
cmpl %eax, %r14d
je 0x2ce42
xorl %eax, %eax
movl 0x4(%rsp), %edx
cmpl $0x3, %edx
movl %r14d, %ecx
cmovnel %edx, %eax
imulq $0x38, %rcx, %rcx
movq 0x8(%rsp), %rdx
addq 0x20(%rdx), %rcx
movq $0x0, 0x18(%rcx,%rax,8)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
cmpb $0x0, 0xa0b0c(%rip)     # 0xcde00
jne 0x2d362
leaq 0x7e472(%rip), %rdx     # 0xab76f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2d3d9
testl %eax, %eax
js 0x2d362
cmpl (%rbx), %eax
jge 0x2d362
movq 0x10(%rbx), %rcx
movl %eax, %eax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
testq %rax, %rax
je 0x2d362
movl 0x10(%rax), %eax
movl %eax, %ecx
notl %ecx
testb $0xf, %cl
sete %cl
andl $0xf00, %eax            # imm = 0xF00
cmpl $0x300, %eax            # imm = 0x300
sete %al
orb %cl, %al
jne 0x2d362
leaq 0x7e42a(%rip), %rsi     # 0xab772
leaq 0x7e438(%rip), %rdx     # 0xab787
movl $0x3, %edi
xorl %eax, %eax
callq 0x942d
movb $0x1, 0xa0a9e(%rip)     # 0xcde00
cmpb $0x0, 0xa0a9b(%rip)     # 0xcde04
jne 0x2d3d7
leaq 0x7e437(%rip), %rdx     # 0xab7a9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2d3d9
testl %eax, %eax
js 0x2d3d7
cmpl (%rbx), %eax
jge 0x2d3d7
movq 0x10(%rbx), %rcx
movl %eax, %eax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
testq %rax, %rax
je 0x2d3d7
movl 0x10(%rax), %eax
movl %eax, %ecx
notl %ecx
testb $0xf, %cl
sete %cl
andl $0xf00, %eax            # imm = 0xF00
cmpl $0x300, %eax            # imm = 0x300
sete %al
orb %cl, %al
jne 0x2d3d7
leaq 0x7e3b5(%rip), %rsi     # 0xab772
leaq 0x7e3e8(%rip), %rdx     # 0xab7ac
movl $0x3, %edi
xorl %eax, %eax
callq 0x942d
movb $0x1, 0xa0a2d(%rip)     # 0xcde04
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq %esi, %rax
movq 0x28(%rdi,%rax,8), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %ecx
testl %ecx, %ecx
je 0x2d42d
movq %rdx, %rbx
movq %rcx, 0x18(%rsp)
leal -0x1(%rcx), %esi
movb (%rdx), %cl
testb %cl, %cl
je 0x2d435
leaq 0x1(%rbx), %rax
movl $0x811c9dc5, %r13d      # imm = 0x811C9DC5
movzbl %cl, %ecx
xorl %r13d, %ecx
imull $0x1000193, %ecx, %r13d # imm = 0x1000193
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x2d415
jmp 0x2d43b
xorl %r15d, %r15d
jmp 0x2d4c5
movl $0x811c9dc5, %r13d      # imm = 0x811C9DC5
andl %esi, %r13d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl $0x1, %r14d
movl %r13d, %r15d
movl %esi, 0x14(%rsp)
movq %rdi, 0x20(%rsp)
movl %r15d, %eax
shrl $0x4, %eax
movl (%rdi,%rax,4), %r12d
leal (%r15,%r15), %ebp
andl $0x1e, %ebp
movl %r12d, %eax
movl %ebp, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x2d4b3
testb $0x1, %al
jne 0x2d49e
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl %r15d, %ecx
movq (%rax,%rcx,8), %rdi
movq %rbx, %rsi
callq 0x46e0
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
testl %eax, %eax
je 0x2d4b3
addl %r14d, %r15d
andl %esi, %r15d
incl %r14d
cmpl %r13d, %r15d
jne 0x2d459
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2d4e3
movl %ebp, %ecx
shrl %cl, %r12d
testb $0x3, %r12b
movq 0x18(%rsp), %rcx
cmovnel %ecx, %r15d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %r15d
je 0x2d4e3
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movl %r15d, %ecx
imulq $0x38, %rcx, %rcx
movl 0x30(%rax,%rcx), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
movq %rdx, 0x10(%r13)
movq %rcx, 0x18(%r13)
movq %r8, 0x20(%r13)
movq %r9, 0x28(%r13)
testb %al, %al
je 0x2dd8a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %r13, 0x10(%rcx)
leaq 0x210(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rbp     # imm = 0x3000000010
movq %rbp, (%rcx)
leaq 0xd0(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x42c0
cmpl $0xff, %eax
jbe 0x2de16
incl %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x46a0
testq %rax, %rax
je 0x2de2a
movq %rax, %r15
movq %rsp, %rcx
movq %r13, 0x10(%rcx)
leaq 0x210(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rbp, (%rcx)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x42c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d739
movl %eax, %ebx
movq %r15, %rdi
callq 0x45c0
jmp 0x2de2f
leaq 0xd0(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d739
movl %eax, %ebx
jmp 0x2de2f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x7d8ff(%rip), %rdx     # 0xab74a
movl $0x5, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2ce51
testq %rax, %rax
je 0x2de65
movq 0x10(%rax), %rax
jmp 0x2de86
leaq 0x7da84(%rip), %rsi     # 0xab8f0
leaq 0x7da91(%rip), %rdx     # 0xab904
movl $0x3, %edi
xorl %eax, %eax
callq 0x942d
leaq 0x7daa0(%rip), %rax     # 0xab926
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7d8a9(%rip), %rdx     # 0xab74a
movl $0x5, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2ce51
testq %rax, %rax
je 0x2df04
movq %rax, %r15
movq %rax, %rdi
callq 0x2acf6
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x2df6a
movq %rax, %r12
movq 0x10(%rax), %rdi
callq 0x45c0
movq %r14, %rdi
callq 0x4930
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x2df6a
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2b8a7
movq %r12, %rdi
callq 0x2ac82
jmp 0x2df5a
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x7da10(%rip), %rsi     # 0xab92e
movq %r14, %rdx
xorl %eax, %eax
callq 0x89557
testl %eax, %eax
js 0x2df65
movq 0x20(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x2b376
movq %rax, %r14
movq 0x20(%rsp), %rdi
callq 0x45c0
movq 0x10(%r14), %rsi
xorl %edi, %edi
callq 0x2bc61
movq 0x28(%rbx), %rcx
movl %eax, 0x38(%rcx)
movl $0x1, 0x54(%rbx)
xorl %ebp, %ebp
jmp 0x2df6a
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/vcf.c
// Function: bcf_hdr_init
bcf_hdr_t *bcf_hdr_init(const char *mode)
{
    int i;
    bcf_hdr_t *h;
    h = (bcf_hdr_t*)calloc(1, sizeof(bcf_hdr_t));
    if (!h) return NULL;
    for (i = 0; i < 3; ++i) {
        if ((h->dict[i] = kh_init(vdict)) == NULL) goto fail;
        // Supersize the hash to make collisions very unlikely
        static int dsize[3] = {16384,16384,2048}; // info, contig, format
        if (kh_resize(vdict, h->dict[i], dsize[i]) < 0) goto fail;
    }

    bcf_hdr_aux_t *aux = (bcf_hdr_aux_t*)calloc(1,sizeof(bcf_hdr_aux_t));
    if ( !aux ) goto fail;
    if ( (aux->gen = kh_init(hdict))==NULL ) { free(aux); goto fail; }
    aux->key_len = NULL;
    aux->dict = *((vdict_t*)h->dict[0]);
    aux->version = 0;
    free(h->dict[0]);
    h->dict[0] = aux;

    if ( strchr(mode,'w') )
    {
        bcf_hdr_append(h, "##fileformat=VCFv4.2");
        // The filter PASS must appear first in the dictionary
        bcf_hdr_append(h, "##FILTER=<ID=PASS,Description=\"All filters passed\">");
        aux->version = VCF_DEF;
    }
    return h;

 fail:
    for (i = 0; i < 3; ++i)
        kh_destroy(vdict, h->dict[i]);
    free(h);
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0xa8, %esi
callq 0x42f0
testq %rax, %rax
je 0x2e0c1
movq %rax, %rbx
xorl %r15d, %r15d
leaq 0x7cfab(%rip), %r12     # 0xaaf54
movl $0x1, %edi
movl $0x28, %esi
callq 0x42f0
movq %rax, 0x28(%rbx,%r15,2)
testq %rax, %rax
je 0x2e07e
movl (%r15,%r12), %esi
movq %rax, %rdi
callq 0x2e0d2
testl %eax, %eax
js 0x2e07e
addq $0x4, %r15
cmpq $0xc, %r15
jne 0x2dfa9
movl $0x1, %edi
movl $0x40, %esi
callq 0x42f0
testq %rax, %rax
je 0x2e07e
movq %rax, %r15
movl $0x1, %edi
movl $0x28, %esi
callq 0x42f0
movq %rax, 0x28(%r15)
testq %rax, %rax
je 0x2e076
movq 0x28(%rbx), %rdi
movq 0x20(%rdi), %rax
movq %rax, 0x20(%r15)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
callq 0x45c0
movq %r15, 0x28(%rbx)
movq %r14, %rdi
movl $0x77, %esi
callq 0x4180
testq %rax, %rax
je 0x2e0c3
leaq 0x7d8e9(%rip), %rsi     # 0xab93e
movq %rbx, %rdi
callq 0x2d739
leaq 0x7d7bd(%rip), %rsi     # 0xab821
movq %rbx, %rdi
callq 0x2d739
movl $0x3d10d0, 0x38(%r15)   # imm = 0x3D10D0
jmp 0x2e0c3
movq %r15, %rdi
callq 0x45c0
movl $0x5, %r15d
movq (%rbx,%r15,8), %r14
testq %r14, %r14
je 0x2e0b0
movq 0x18(%r14), %rdi
callq 0x45c0
movq 0x10(%r14), %rdi
callq 0x45c0
movq 0x20(%r14), %rdi
callq 0x45c0
movq %r14, %rdi
callq 0x45c0
incq %r15
cmpq $0x8, %r15
jne 0x2e084
movq %rbx, %rdi
callq 0x45c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/vcf.c
// Function: bcf_hdr_destroy
void bcf_hdr_destroy(bcf_hdr_t *h)
{
    int i;
    khint_t k;
    if (!h) return;
    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));
        if ( i==0 )
        {
            bcf_hdr_aux_t *aux = get_hdr_aux(h);
            for (k=kh_begin(aux->gen); k<kh_end(aux->gen); k++)
                if ( kh_exist(aux->gen,k) ) free((char*)kh_key(aux->gen,k));
            kh_destroy(hdict, aux->gen);
            free(aux->key_len); // may exist for dict[0] only
        }
        kh_destroy(vdict, d);
        free(h->id[i]);
    }
    for (i=0; i<h->nhrec; i++)
        bcf_hrec_destroy(h->hrec[i]);
    if (h->nhrec) free(h->hrec);
    if (h->samples) free(h->samples);
    free(h->keep_samples);
    free(h->transl[0]); free(h->transl[1]);
    free(h->mem.s);
    free(h);
}

// Assembly:
testq %rdi, %rdi
je 0x2e616
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
xorl %r12d, %r12d
movq %rdi, (%rsp)
movq 0x28(%r15,%r12,8), %r14
testq %r14, %r14
je 0x2e58e
movl (%r14), %eax
testl %eax, %eax
je 0x2e4de
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x10(%r14), %rcx
movl %ebp, %edx
shrl $0x4, %edx
movl (%rcx,%rdx,4), %edx
movl %ebx, %ecx
andb $0x1e, %cl
shrl %cl, %edx
testb $0x3, %dl
jne 0x2e4d5
movq 0x18(%r14), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x45c0
movl (%r14), %eax
incl %ebp
addl $0x2, %ebx
cmpl %eax, %ebp
jne 0x2e4ab
testq %r12, %r12
jne 0x2e561
movq 0x28(%r15), %r13
movq 0x28(%r13), %r15
movl (%r15), %eax
testl %eax, %eax
je 0x2e531
xorl %ebp, %ebp
xorl %ebx, %ebx
movq 0x10(%r15), %rcx
movq %rbx, %rdx
shrq $0x4, %rdx
movl (%rcx,%rdx,4), %edx
movl %ebp, %ecx
andb $0x1e, %cl
shrl %cl, %edx
testb $0x3, %dl
jne 0x2e524
movq 0x18(%r15), %rax
movq (%rax,%rbx,8), %rdi
callq 0x45c0
movq 0x28(%r13), %r15
movl (%r15), %eax
incq %rbx
movl %eax, %ecx
addl $0x2, %ebp
cmpq %rcx, %rbx
jb 0x2e4f6
movq 0x18(%r15), %rdi
callq 0x45c0
movq 0x10(%r15), %rdi
callq 0x45c0
movq 0x20(%r15), %rdi
callq 0x45c0
movq %r15, %rdi
callq 0x45c0
movq 0x30(%r13), %rdi
callq 0x45c0
movq (%rsp), %r15
movq 0x18(%r14), %rdi
callq 0x45c0
movq 0x10(%r14), %rdi
callq 0x45c0
movq 0x20(%r14), %rdi
callq 0x45c0
movq %r14, %rdi
callq 0x45c0
movq 0x10(%r15,%r12,8), %rdi
callq 0x45c0
incq %r12
cmpq $0x3, %r12
jne 0x2e492
movl 0x50(%r15), %eax
testl %eax, %eax
jle 0x2e5be
xorl %ebx, %ebx
movq 0x48(%r15), %rax
movq (%rax,%rbx,8), %rdi
callq 0x2ac82
incq %rbx
movslq 0x50(%r15), %rax
cmpq %rax, %rbx
jl 0x2e5a5
testl %eax, %eax
je 0x2e5cb
movq 0x48(%r15), %rdi
callq 0x45c0
movq 0x40(%r15), %rdi
testq %rdi, %rdi
je 0x2e5d9
callq 0x45c0
movq 0x78(%r15), %rdi
callq 0x45c0
movq 0x60(%r15), %rdi
callq 0x45c0
movq 0x68(%r15), %rdi
callq 0x45c0
movq 0x90(%r15), %rdi
callq 0x45c0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45c0
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x2f340
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x54(%rsi)
je 0x2f30e
movq %r14, %rdi
callq 0x2ab97
testl %eax, %eax
js 0x2f34b
movl $0x2, 0x48(%rbx)
movl 0x4c(%rbx), %eax
cmpl $0x1, %eax
je 0x2f35a
cmpl $0x8, %eax
je 0x2f327
cmpl $0x2, %eax
jne 0x2f361
movl $0x8, 0x4c(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x2f484
callq 0x4050
movl $0x16, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x9, 0x4c(%rbx)
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x2f5bf
testl %eax, %eax
js 0x2f3ce
movq (%rsp), %rcx
leaq 0x2(%rcx), %rax
cmpq %rax, 0x8(%rsp)
jae 0x2f3dd
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rax, %rdx
shrq %rdx
xorl %r14d, %r14d
testq %rcx, %rcx
cmoveq %rdx, %r14
addq %rax, %r14
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x4860
testq %rax, %rax
je 0x2f3fb
movq %rax, 0x10(%rsp)
movq %r14, 0x8(%rsp)
movq (%rsp), %rcx
jmp 0x2f3e2
movq 0x10(%rsp), %rdi
callq 0x45c0
jmp 0x2f34b
movq 0x10(%rsp), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsp)
xorl %edx, %edx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rcx,%rax)
movq 0x38(%rbx), %r14
leaq 0x7c609(%rip), %rsi     # 0xaba0f
movl $0x5, %edx
movq %r14, %rdi
callq 0x8caa5
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $0x5, %rax
jne 0x2f350
movl (%rsp), %eax
leaq 0x24(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x8caa5
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $0x4, %rax
jne 0x2f350
movq (%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8caa5
cmpq (%rsp), %rax
jne 0x2f350
movq %r14, %rdi
callq 0x8c625
testl %eax, %eax
js 0x2f350
movq 0x10(%rsp), %rdi
callq 0x45c0
xorl %ebx, %ebx
jmp 0x2f350
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x2f5bf
testl %eax, %eax
js 0x2f514
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x2f4d1
movq 0x10(%rsp), %rax
cmpb $0x0, -0x1(%rax,%rbx)
jne 0x2f4d3
decq %rbx
movq %rbx, (%rsp)
jne 0x2f4c1
xorl %ebx, %ebx
cmpl $0x0, 0x54(%r12)
movq 0x38(%r12), %r15
movq 0x10(%rsp), %r14
je 0x2f528
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8caa5
movq %rax, %r13
movq 0x38(%r12), %rdi
callq 0x8c625
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x2f5b1
jmp 0x2f5a0
movq 0x10(%rsp), %rdi
callq 0x45c0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2f5b1
testb $0x2, 0x30(%r15)
movq 0x18(%r15), %r12
jne 0x2f558
movq %r12, %rax
subq 0x8(%r15), %rax
cmpq %rbx, %rax
jae 0x2f558
addq %rbx, %r12
subq (%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x98194
movq 0x18(%r15), %r12
movq %r12, 0x10(%r15)
movq 0x8(%r15), %rdi
subq %rdi, %r12
cmpq %rbx, %r12
ja 0x2f569
cmpq (%r15), %rdi
je 0x2f589
cmpq %rbx, %r12
movq %rbx, %r13
cmovbq %r12, %r13
movq %r14, %rsi
movq %r13, %rdx
callq 0x43c0
addq %r13, 0x8(%r15)
cmpq %rbx, %r12
jb 0x2f58c
jmp 0x2f5a0
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x98670
movq %rax, %r13
movq 0x10(%rsp), %rdi
callq 0x45c0
movslq %r13d, %rax
shrq $0x1f, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x0, 0x50(%rdi)
jle 0x2f601
movl %esi, %ebp
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x48(%r14), %rax
movq (%rax,%r12,8), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x31cb5
shrl $0x1f, %eax
orl %eax, %r15d
incq %r12
movslq 0x50(%r14), %rax
cmpq %rax, %r12
jl 0x2f5db
jmp 0x2f604
xorl %r15d, %r15d
leaq 0x7be45(%rip), %rsi     # 0xab450
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89557
movl %eax, %ebp
cmpl $0x0, 0x8(%r14)
je 0x2f670
leaq 0x7c5a8(%rip), %rsi     # 0xabbcd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89557
orl %eax, %ebp
shrl $0x1f, %ebp
orl %r15d, %ebp
cmpl $0x0, 0x8(%r14)
jle 0x2f676
leaq 0x7bf2a(%rip), %r15     # 0xab56f
xorl %r12d, %r12d
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x89557
shrl $0x1f, %eax
orl %eax, %ebp
incq %r12
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jl 0x2f648
jmp 0x2f676
shrl $0x1f, %ebp
orl %r15d, %ebp
leaq 0x79536(%rip), %rsi     # 0xa8bb3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89557
shrl $0x1f, %eax
xorl %ecx, %ecx
orl %ebp, %eax
setne %cl
negl %ecx
movl %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/vcf.c
// Function: bcf_clear
void bcf_clear(bcf1_t *v)
{
    int i;
    for (i=0; i<v->d.m_info; i++)
    {
        if ( v->d.info[i].vptr_free )
        {
            free(v->d.info[i].vptr - v->d.info[i].vptr_off);
            v->d.info[i].vptr_free = 0;
        }
    }
    for (i=0; i<v->d.m_fmt; i++)
    {
        if ( v->d.fmt[i].p_free )
        {
            free(v->d.fmt[i].p - v->d.fmt[i].p_off);
            v->d.fmt[i].p_free = 0;
        }
    }
    v->rid = v->pos = v->rlen = v->unpacked = 0;
    bcf_float_set_missing(v->qual);
    v->n_info = v->n_allele = v->n_fmt = v->n_sample = 0;
    v->shared.l = v->indiv.l = 0;
    v->d.var_type = -1;
    v->d.shared_dirty = 0;
    v->d.indiv_dirty  = 0;
    v->d.n_flt = 0;
    v->errcode = 0;
    if (v->d.m_als) v->d.als[0] = 0;
    if (v->d.m_id) v->d.id[0] = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x54(%rdi), %eax
testl %eax, %eax
jle 0x2f708
movl $0x1c, %r14d
xorl %r15d, %r15d
movq 0x90(%rbx), %rdx
movl (%rdx,%r14), %ecx
testl %ecx, %ecx
jns 0x2f6f9
movq -0xc(%rdx,%r14), %rdi
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
subq %rcx, %rdi
callq 0x45c0
movq 0x90(%rbx), %rax
andl $0x7fffffff, (%rax,%r14) # imm = 0x7FFFFFFF
movl 0x54(%rbx), %eax
incq %r15
movslq %eax, %rcx
addq $0x28, %r14
cmpq %rcx, %r15
jl 0x2f6c5
movl 0x50(%rbx), %eax
testl %eax, %eax
jle 0x2f75b
movl $0x1c, %r14d
xorl %r15d, %r15d
movq 0x98(%rbx), %rdx
movl (%rdx,%r14), %ecx
testl %ecx, %ecx
jns 0x2f74c
movq -0xc(%rdx,%r14), %rdi
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
subq %rcx, %rdi
callq 0x45c0
movq 0x98(%rbx), %rax
andl $0x7fffffff, (%rax,%r14) # imm = 0x7FFFFFFF
movl 0x50(%rbx), %eax
incq %r15
movslq %eax, %rcx
addq $0x20, %r14
cmpq %rcx, %r15
jl 0x2f718
xorl %eax, %eax
movl %eax, 0xbc(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl %eax, 0x10(%rbx)
movl 0x9dd9e(%rip), %ecx     # 0xcd510
movl %ecx, 0x14(%rbx)
movq $0x0, 0x38(%rbx)
movups %xmm0, 0x18(%rbx)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0xac(%rbx)
movl %eax, 0xb4(%rbx)
movl %eax, 0x68(%rbx)
movl %eax, 0xcc(%rbx)
cmpl %eax, 0x5c(%rbx)
je 0x2f7ab
movq 0x80(%rbx), %rax
movb $0x0, (%rax)
cmpl $0x0, 0x58(%rbx)
je 0x2f7b8
movq 0x78(%rbx), %rax
movb $0x0, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2f6ad
movq 0x78(%rbx), %rdi
callq 0x45c0
movq 0x80(%rbx), %rdi
callq 0x45c0
movq 0x88(%rbx), %rdi
callq 0x45c0
movq 0x70(%rbx), %rdi
callq 0x45c0
movq 0x90(%rbx), %rdi
callq 0x45c0
movq 0x98(%rbx), %rdi
callq 0x45c0
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x2f81d
callq 0x45c0
leaq 0x20(%rbx), %r14
movq 0x30(%rbx), %rdi
callq 0x45c0
movq 0x48(%rbx), %rdi
callq 0x45c0
movl $0x98, %edx
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4250
// File: /workspace/github_c_makefile_star2_O3/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:
movzbl (%rdi), %eax
andl $0xf, %eax
decl %eax
cmpl $0x3, %eax
ja 0x2fbd6
leaq 0x7b0ac(%rip), %rcx     # 0xaac50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2(%rdi), %rax
movsbq 0x1(%rdi), %rcx
jmp 0x2fbdb
leaq 0x5(%rdi), %rax
movl 0x1(%rdi), %ecx
jmp 0x2fbdb
leaq 0x9(%rdi), %rax
movq 0x1(%rdi), %rcx
jmp 0x2fbdb
leaq 0x3(%rdi), %rax
movswq 0x1(%rdi), %rcx
jmp 0x2fbdb
xorl %ecx, %ecx
movq %rdi, %rax
movl %ecx, (%rdx)
movzbl (%rax), %ecx
andl $0xf, %ecx
movl %ecx, 0xc(%rdx)
movzbl (%rax), %r8d
cmpl $0xef, %r8d
jbe 0x2fc21
movzbl 0x1(%rax), %r8d
andl $0xf, %r8d
decl %r8d
cmpl $0x3, %r8d
ja 0x2fc74
leaq 0x7b054(%rip), %r9      # 0xaac60
movslq (%r9,%r8,4), %r8
addq %r9, %r8
jmpq *%r8
movsbq 0x2(%rax), %r8
addq $0x3, %rax
jmp 0x2fc28
incq %rax
shrl $0x4, %r8d
movl %r8d, 0x4(%rdx)
leaq 0x9d8ed(%rip), %r9      # 0xcd520
movb (%rcx,%r9), %cl
shll %cl, %r8d
movl %r8d, 0x8(%rdx)
movq %rax, 0x10(%rdx)
subl %edi, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, 0x1c(%rdx)
imull %esi, %r8d
movl %r8d, 0x18(%rdx)
retq
movl 0x2(%rax), %r8d
addq $0x6, %rax
jmp 0x2fc28
movq 0x2(%rax), %r8
addq $0xa, %rax
jmp 0x2fc28
movswq 0x2(%rax), %r8
addq $0x4, %rax
jmp 0x2fc28
xorl %r8d, %r8d
jmp 0x2fc28
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x8, 0x4c(%rdi)
jne 0x2fc98
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x2fcd6
movq 0x38(%rdi), %rdi
movq %rbx, %rsi
callq 0x2fd0f
testl %eax, %eax
jne 0x2fcb7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fea9
testl %eax, %eax
je 0x2fcc0
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
cmpq $0x0, 0x78(%r14)
je 0x2fcb9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f861
jmp 0x2fcb9
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rdx, %rsi
callq 0x2fd0f
testl %eax, %eax
jne 0x309d1
xorl %edi, %edi
movq %r14, %rsi
callq 0x2fea9
testl %eax, %eax
js 0x309d1
movl 0x10(%r14), %ecx
movl %ecx, (%r12)
movq (%r14), %rcx
movq %rcx, (%r15)
addq 0x8(%r14), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/vcf.c
// Function: bcf_copy
bcf1_t *bcf_copy(bcf1_t *dst, bcf1_t *src)
{
    bcf1_sync(src);

    bcf_clear(dst);
    dst->rid  = src->rid;
    dst->pos  = src->pos;
    dst->rlen = src->rlen;
    dst->qual = src->qual;
    dst->n_info = src->n_info; dst->n_allele = src->n_allele;
    dst->n_fmt = src->n_fmt; dst->n_sample = src->n_sample;

    if ( dst->shared.m < src->shared.l )
    {
        dst->shared.s = (char*) realloc(dst->shared.s, src->shared.l);
        dst->shared.m = src->shared.l;
    }
    dst->shared.l = src->shared.l;
    memcpy(dst->shared.s,src->shared.s,dst->shared.l);

    if ( dst->indiv.m < src->indiv.l )
    {
        dst->indiv.s = (char*) realloc(dst->indiv.s, src->indiv.l);
        dst->indiv.m = src->indiv.l;
    }
    dst->indiv.l = src->indiv.l;
    memcpy(dst->indiv.s,src->indiv.s,dst->indiv.l);

    return dst;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x30aea
movq %rbx, %rdi
callq 0x2f6ad
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movss 0x14(%r14), %xmm0
movss %xmm0, 0x14(%rbx)
movq 0x18(%rbx), %rcx
movq 0x28(%rbx), %rax
movw 0x18(%r14), %cx
movq %rcx, 0x18(%rbx)
movzwl 0x1a(%r14), %edx
shll $0x10, %edx
movabsq $-0xffff0001, %rsi      # imm = 0xFFFFFFFF0000FFFF
andq %rcx, %rsi
orq %rdx, %rsi
movq %rsi, 0x18(%rbx)
movzbl 0x1c(%r14), %ecx
shlq $0x20, %rcx
movabsq $-0xff00000001, %rdx    # imm = 0xFFFFFF00FFFFFFFF
andq %rsi, %rdx
orq %rcx, %rdx
movq %rdx, 0x18(%rbx)
movabsq $-0x10000000000, %rcx   # imm = 0xFFFFFF0000000000
andq 0x18(%r14), %rcx
movabsq $0xffffffffff, %rsi     # imm = 0xFFFFFFFFFF
andq %rdx, %rsi
orq %rcx, %rsi
movq %rsi, 0x18(%rbx)
movq 0x20(%r14), %rdx
movq 0x30(%rbx), %rdi
cmpq %rdx, %rax
jae 0x30aa0
movq %rdx, %rsi
callq 0x4860
movq %rax, %rdi
movq %rax, 0x30(%rbx)
movq 0x20(%r14), %rdx
movq %rdx, 0x28(%rbx)
movq %rdx, 0x20(%rbx)
movq 0x30(%r14), %rsi
callq 0x43c0
movq 0x38(%r14), %rdx
movq 0x48(%rbx), %rdi
cmpq %rdx, 0x40(%rbx)
jae 0x30ad2
movq %rdx, %rsi
callq 0x4860
movq %rax, %rdi
movq %rax, 0x48(%rbx)
movq 0x38(%r14), %rdx
movq %rdx, 0x40(%rbx)
movq %rdx, 0x38(%rbx)
movq 0x48(%r14), %rsi
callq 0x43c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rsi, %rsi
sete %al
cmpq $0x4, %rdx
setb %cl
orb %al, %cl
je 0x31b25
xorl %ebx, %ebx
jmp 0x31b8c
movq %rsi, %rbx
movl %edi, %ebp
testl %edi, %edi
je 0x31b89
movq %rdx, %r14
movl $0x8, %r12d
leaq 0x9ac32(%rip), %r13     # 0xcc770
movl -0x8(%r12,%r13), %r15d
testl %ebp, %r15d
je 0x31b64
movq (%r12,%r13), %rcx
movq %rbx, %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x40fb8
testl %eax, %eax
js 0x31b8c
notl %r15d
andl %r15d, %ebp
addq $0x10, %r12
cmpq $0x78, %r12
jne 0x31b3e
testl %ebp, %ebp
je 0x31b8c
leaq 0x7a8a2(%rip), %rcx     # 0xac41b
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40fb8
jmp 0x31b8c
movb $0x0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r15
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %rax, %rdi
callq 0xb240
movl $0x1, %ebx
testq %rax, %rax
je 0x31c9d
movq %rax, %r14
movslq (%rsp), %rax
cmpq $0x2, %rax
jl 0x31c27
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movq (%r14,%rbp,8), %rsi
movq %r12, %rdx
callq 0x2b376
testq %rax, %rax
je 0x31c6a
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
callq 0x2bd95
testl %eax, %eax
js 0x31c62
movq (%r14,%rbp,8), %rdi
callq 0x45c0
movq $0x0, (%r14,%rbp,8)
incq %rbp
movslq (%rsp), %rax
decq %rax
cmpq %rax, %rbp
jl 0x31be2
jmp 0x31c2c
decq %rax
xorl %ebp, %ebp
movq (%r14,%rax,8), %rsi
movq %r15, %rdi
callq 0x2aaa0
testl %eax, %eax
js 0x31c6a
movq %r15, %rdi
callq 0x2ab97
testl %eax, %eax
js 0x31c6a
movslq (%rsp), %rax
movq -0x8(%r14,%rax,8), %rdi
callq 0x45c0
movq %r14, %rdi
callq 0x45c0
xorl %ebx, %ebx
jmp 0x31c9d
movq %r13, %rdi
callq 0x2ac82
callq 0x4050
movq %rax, %r15
movl (%rax), %r12d
cmpl (%rsp), %ebp
jge 0x31c92
movl %ebp, %r13d
movq (%r14,%r13,8), %rdi
callq 0x45c0
incq %r13
movslq (%rsp), %rax
cmpq %rax, %r13
jl 0x31c7d
movq %r14, %rdi
callq 0x45c0
movl %r12d, (%r15)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x31ce9
leaq 0x798d9(%rip), %rsi     # 0xab5b0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89557
shrl $0x1f, %eax
jmp 0x31e06
movl %esi, %r14d
movq %rdi, %r15
leaq 0x798a9(%rip), %rsi     # 0xab59f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89557
movl %eax, %ebp
shrl $0x1f, %ebp
movl 0x18(%r15), %r12d
testl %r12d, %r12d
jle 0x31df0
movl %r14d, 0x4(%rsp)
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpl $0x0, 0x4(%rsp)
jne 0x31d40
movq 0x20(%r15), %rax
movq (%rax,%r13,8), %rsi
leaq 0x75d50(%rip), %rdi     # 0xa7a83
callq 0x46e0
testl %eax, %eax
je 0x31dd8
testl %r14d, %r14d
je 0x31dab
movq (%rbx), %rcx
leaq 0x2(%rcx), %rax
cmpq %rax, 0x8(%rbx)
jae 0x31d8d
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rax, %rdx
shrq %rdx
testq %rcx, %rcx
movl $0x0, %r12d
cmoveq %rdx, %r12
addq %rax, %r12
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4860
testq %rax, %rax
je 0x31de9
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rcx
jmp 0x31d91
movq 0x10(%rbx), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb $0x2c, (%rax,%rcx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movb $0x0, (%rcx,%rax)
xorl %eax, %eax
orl %eax, %ebp
movq 0x20(%r15), %rax
movq 0x28(%r15), %rcx
movq (%rax,%r13,8), %rdx
movq (%rcx,%r13,8), %rcx
movq %rbx, %rdi
leaq 0x7997f(%rip), %rsi     # 0xab744
xorl %eax, %eax
callq 0x89557
shrl $0x1f, %eax
orl %eax, %ebp
incl %r14d
movl 0x18(%r15), %r12d
incq %r13
movslq %r12d, %rax
cmpq %rax, %r13
jl 0x31d1d
jmp 0x31df0
movl $0x1, %eax
jmp 0x31da9
leaq 0x797b6(%rip), %rsi     # 0xab5ad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89557
shrl $0x1f, %eax
orl %ebp, %eax
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq %rdx, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
callq 0x2f5bf
testl %eax, %eax
js 0x31e50
testq %rbx, %rbx
je 0x31e49
movl (%rsp), %eax
movl %eax, (%rbx)
movq 0x10(%rsp), %rax
jmp 0x31e52
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
cmpl $0xe, %esi
jg 0x32895
leaq 0x1(%rcx), %rax
cmpq %rax, %rdx
jae 0x328d6
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rax, %rdx
shrq %rdx
xorl %r15d, %r15d
testq %rcx, %rcx
cmoveq %rdx, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x32937
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq (%rbx), %rcx
jmp 0x328da
leaq 0x6(%rcx), %rax
cmpq %rax, %rdx
jae 0x328eb
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rax, %rdx
shrq %rdx
xorl %r15d, %r15d
testq %rcx, %rcx
cmoveq %rdx, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x32937
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq (%rbx), %rcx
jmp 0x328ef
movq 0x10(%rbx), %rax
shll $0x4, %ebp
orl %r14d, %ebp
movb %bpl, (%rax,%rcx)
movl $0x1, %eax
jmp 0x32934
movq 0x10(%rbx), %rax
orb $-0x10, %r14b
movb %r14b, (%rax,%rcx)
cmpl $0x7f, %ebp
ja 0x3290d
movb $0x11, 0x1(%rax,%rcx)
movb %bpl, 0x2(%rax,%rcx)
movl $0x3, %eax
jmp 0x32934
cmpl $0x7fff, %ebp           # imm = 0x7FFF
ja 0x32926
movb $0x12, 0x1(%rax,%rcx)
movw %bp, 0x2(%rax,%rcx)
movl $0x4, %eax
jmp 0x32934
movb $0x13, 0x1(%rax,%rcx)
movl %ebp, 0x2(%rax,%rcx)
movl $0x6, %eax
addq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
js 0x32acb
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
cmpl $0xe, %esi
ja 0x329ab
leaq 0x1(%rcx), %rax
cmpq %rax, %rdx
jae 0x329ec
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rax, %rdx
shrq %rdx
xorl %r15d, %r15d
testq %rcx, %rcx
cmoveq %rdx, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
movq (%rbx), %rcx
testq %rax, %rax
je 0x32a4d
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
jmp 0x329f0
leaq 0x6(%rcx), %rax
cmpq %rax, %rdx
jae 0x32a02
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rax, %rdx
shrq %rdx
xorl %r15d, %r15d
testq %rcx, %rcx
cmoveq %rdx, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
movq (%rbx), %rcx
testq %rax, %rax
je 0x32a4d
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
jmp 0x32a06
movq 0x10(%rbx), %rax
movl %ebp, %edx
shlb $0x4, %dl
orb $0x5, %dl
movb %dl, (%rax,%rcx)
movl $0x1, %ecx
jmp 0x32a47
movq 0x10(%rbx), %rax
movb $-0xb, (%rax,%rcx)
cmpl $0x7f, %ebp
ja 0x32a20
movb $0x11, 0x1(%rax,%rcx)
movb %bpl, 0x2(%rax,%rcx)
movl $0x3, %ecx
jmp 0x32a47
cmpl $0x7fff, %ebp           # imm = 0x7FFF
ja 0x32a39
movb $0x12, 0x1(%rax,%rcx)
movw %bp, 0x2(%rax,%rcx)
movl $0x4, %ecx
jmp 0x32a47
movb $0x13, 0x1(%rax,%rcx)
movl %ebp, 0x2(%rax,%rcx)
movl $0x6, %ecx
addq (%rbx), %rcx
movq %rcx, (%rbx)
movl %ebp, %r12d
leaq (%rcx,%r12,4), %rax
cmpq %rax, 0x8(%rbx)
jae 0x32a92
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rax, %rdx
shrq %rdx
xorl %r15d, %r15d
testq %rcx, %rcx
cmoveq %rdx, %r15
addq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x4860
testq %rax, %rax
je 0x32ac0
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq (%rbx), %rcx
jmp 0x32a96
movq 0x10(%rbx), %rax
leaq (,%r12,4), %rdx
testl %ebp, %ebp
je 0x32aba
addq %rcx, %rax
xorl %esi, %esi
movss (%r14,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,4)
incq %rsi
cmpq %rsi, %r12
jne 0x32aa7
addq %rdx, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7912e(%rip), %rdi     # 0xabc00
leaq 0x78afa(%rip), %rsi     # 0xab5d3
leaq 0x79127(%rip), %rcx     # 0xabc07
movl $0xaa4, %edx            # imm = 0xAA4
callq 0x42e0