LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_update_id
int bcf_update_id(const bcf_hdr_t *hdr, bcf1_t *line, const char *id)
{
    if ( !(line->unpacked & BCF_UN_STR) ) bcf_unpack(line, BCF_UN_STR);
    kstring_t tmp;
    tmp.l = 0; tmp.s = line->d.id; tmp.m = line->d.m_id;
    if ( id )
        kputs(id, &tmp);
    else
        kputs(".", &tmp);
    line->d.id = tmp.s; line->d.m_id = tmp.m;
    line->d.shared_dirty |= BCF1_DIRTY_ID;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xbc(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4fb04
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x48110
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4fb3a
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x43910
jmp 0x4fb4a
leaq 0xb83fe(%rip), %rdi     # 0x107f3f
leaq -0x30(%rbp), %rsi
callq 0x43910
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rax
movl 0xb0(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xb0(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_add_id
int bcf_add_id(const bcf_hdr_t *hdr, bcf1_t *line, const char *id)
{
    if ( !id ) return 0;
    if ( !(line->unpacked & BCF_UN_STR) ) bcf_unpack(line, BCF_UN_STR);

    kstring_t tmp;
    tmp.l = 0; tmp.s = line->d.id; tmp.m = line->d.m_id;

    int len = strlen(id);
    char *dst = line->d.id;
    while ( *dst && (dst=strstr(dst,id)) )
    {
        if ( dst[len]!=0 && dst[len]!=';' ) dst++;              // a prefix, not a match
        else if ( dst==line->d.id || dst[-1]==';' ) return 0;   // already present
        dst++;  // a suffix, not a match
    }
    if ( line->d.id && (line->d.id[0]!='.' || line->d.id[1]) )
    {
        tmp.l = strlen(line->d.id);
        kputc(';',&tmp);
    }
    kputs(id,&tmp);

    line->d.id = tmp.s; line->d.m_id = tmp.m;
    line->d.shared_dirty |= BCF1_DIRTY_ID;
    return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4fba7
movl $0x0, -0x4(%rbp)
jmp 0x4fd29
movq -0x18(%rbp), %rax
movl 0xbc(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4fbc7
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x48110
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x41a0
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
je 0x4fc2b
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x40b0
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x4fc34
jmp 0x4fc9e
movq -0x48(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x4fc64
movq -0x48(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
je 0x4fc64
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x4fc8d
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x78(%rcx), %rax
je 0x4fc7f
movq -0x48(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x3b, %eax
jne 0x4fc8b
movl $0x0, -0x4(%rbp)
jmp 0x4fd29
jmp 0x4fc8d
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x4fbff
movq -0x18(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4fce9
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x4fcca
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x4fce9
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x41a0
movq %rax, -0x38(%rbp)
movl $0x3b, %edi
leaq -0x38(%rbp), %rsi
callq 0x40b10
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x43910
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x18(%rbp), %rax
movl 0xb0(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xb0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_get_fmt_id
bcf_fmt_t *bcf_get_fmt_id(bcf1_t *line, const int id)
{
    int i;
    if ( !(line->unpacked & BCF_UN_FMT) ) bcf_unpack(line, BCF_UN_FMT);
    for (i=0; i<line->n_fmt; i++)
    {
        if ( line->d.fmt[i].id==id ) return &line->d.fmt[i];
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xbc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x4fe0f
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x48110
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x20, %rcx
andq $0xff, %rcx
cmpl %ecx, %eax
jge 0x4fe76
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x4fe69
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4fe7e
jmp 0x4fe6b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4fe16
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_get_info_id
bcf_info_t *bcf_get_info_id(bcf1_t *line, const int id)
{
    int i;
    if ( !(line->unpacked & BCF_UN_INFO) ) bcf_unpack(line, BCF_UN_INFO);
    for (i=0; i<line->n_info; i++)
    {
        if ( line->d.info[i].key==id ) return &line->d.info[i];
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xbc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x4ff5f
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x48110
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
cmpl %ecx, %eax
jge 0x4ffc2
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x4ffb5
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4ffca
jmp 0x4ffb7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4ff66
movq $0x0, -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: add_desc_to_buffer
static int add_desc_to_buffer(char *buffer, size_t *offset, size_t maxbuffer, const char *description) {

    if (!description || !buffer || !offset || (maxbuffer < 4))
        return -1;

    size_t rembuffer = maxbuffer - *offset;
    if (rembuffer > (strlen(description) + (rembuffer == maxbuffer ? 0 : 1))) {    //add description with optionally required ','
        *offset += snprintf(buffer + *offset, rembuffer, "%s%s", (rembuffer == maxbuffer)? "": ",", description);
    } else {    //not enough space for description, put ...
        size_t tmppos = (rembuffer <= 4) ? maxbuffer - 4 : *offset;
        snprintf(buffer + tmppos, 4, "...");    //ignore offset update
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x51364
cmpq $0x0, -0x10(%rbp)
je 0x51364
cmpq $0x0, -0x18(%rbp)
je 0x51364
cmpq $0x4, -0x20(%rbp)
jae 0x51370
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x51457
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x41a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %r8
movl $0x1, %edx
xorl %esi, %esi
cmpq %r8, %rdi
cmovel %esi, %edx
movslq %edx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x51404
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
addq (%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %r8
leaq 0xb4997(%rip), %rcx     # 0x105d6c
leaq 0xb264e(%rip), %rax     # 0x103a2a
cmpq %r8, %rdx
cmoveq %rax, %rcx
movq -0x28(%rbp), %r8
leaq 0xb280e(%rip), %rdx     # 0x103bfc
movb $0x0, %al
callq 0x4800
movslq %eax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x51450
cmpq $0x4, -0x30(%rbp)
ja 0x51419
movq -0x20(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x48(%rbp)
jmp 0x51424
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
movl $0x4, %esi
leaq 0xb3735(%rip), %rdx     # 0x104b75
movb $0x0, %al
callq 0x4800
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x51457
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/kstring.h
// Function: kinsert_char
static inline int kinsert_char(char c, size_t pos, kstring_t *s)
{
    if (!s || pos > s->l)  {
        return EOF;
    }
    if (ks_resize(s, s->l + 2) < 0) {
        return EOF;
    }
    memmove(s->s + pos + 1, s->s + pos, s->l - pos);
    s->s[pos] = c;
    s->s[++s->l] = 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5148a
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x51496
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5151b
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x2, %rsi
callq 0x44ba0
cmpl $0x0, %eax
jge 0x514b8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5151b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
addq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
subq -0x10(%rbp), %rdx
callq 0x4830
movb -0x5(%rbp), %dl
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb $0x0, 0x1(%rax,%rcx)
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_hrec_set_type
static void bcf_hrec_set_type(bcf_hrec_t *hrec)
{
    if ( !strcmp(hrec->key, "contig") ) hrec->type = BCF_HL_CTG;
    else if ( !strcmp(hrec->key, "INFO") ) hrec->type = BCF_HL_INFO;
    else if ( !strcmp(hrec->key, "FILTER") ) hrec->type = BCF_HL_FLT;
    else if ( !strcmp(hrec->key, "FORMAT") ) hrec->type = BCF_HL_FMT;
    else if ( hrec->nkeys>0 ) hrec->type = BCF_HL_STR;
    else hrec->type = BCF_HL_GEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xb7512(%rip), %rsi     # 0x10915d
callq 0x46b0
cmpl $0x0, %eax
jne 0x51c64
movq -0x8(%rbp), %rax
movl $0x3, (%rax)
jmp 0x51cfb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xb588f(%rip), %rsi     # 0x107502
callq 0x46b0
cmpl $0x0, %eax
jne 0x51c89
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
jmp 0x51cf9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xb21ff(%rip), %rsi     # 0x103e97
callq 0x46b0
cmpl $0x0, %eax
jne 0x51cae
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
jmp 0x51cf7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xb5fde(%rip), %rsi     # 0x107c9b
callq 0x46b0
cmpl $0x0, %eax
jne 0x51cd3
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
jmp 0x51cf5
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0x51ce9
movq -0x8(%rbp), %rax
movl $0x4, (%rax)
jmp 0x51cf3
movq -0x8(%rbp), %rax
movl $0x5, (%rax)
jmp 0x51cf5
jmp 0x51cf7
jmp 0x51cf9
jmp 0x51cfb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_dec_size_safe
static int bcf_dec_size_safe(uint8_t *p, uint8_t *end, uint8_t **q,
                             int *num, int *type) {
    int r;
    if (p >= end) return -1;
    *type = *p & 0xf;
    if (*p>>4 != 15) {
        *q = p + 1;
        *num = *p >> 4;
        return 0;
    }
    r = bcf_dec_typed_int1_safe(p + 1, end, q, num);
    if (r) return r;
    return *num >= 0 ? 0 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x51f12
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x51f99
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
andl $0xf, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
cmpl $0xf, %eax
je 0x51f59
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
sarl $0x4, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x51f99
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x52010
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x51f83
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x51f99
movq -0x28(%rbp), %rax
movl (%rax), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovgel %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: get_type_name
static const char *get_type_name(int type) {
    const char *types[9] = {
        "null", "int (8-bit)", "int (16 bit)", "int (32 bit)",
        "unknown", "float", "unknown", "char", "unknown"
    };
    int t = (type >= 0 && type < 8) ? type : 8;
    return types[t];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0xd2bea(%rip), %rsi     # 0x124bb0
movl $0x48, %edx
callq 0x43b0
cmpl $0x0, -0x4(%rbp)
jl 0x51fe4
cmpl $0x8, -0x4(%rbp)
jge 0x51fe4
movl -0x4(%rbp), %eax
movl %eax, -0x58(%rbp)
jmp 0x51fee
movl $0x8, %eax
movl %eax, -0x58(%rbp)
jmp 0x51fee
movl -0x58(%rbp), %eax
movl %eax, -0x54(%rbp)
movslq -0x54(%rbp), %rax
movq -0x50(%rbp,%rax,8), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_dec_typed_int1_safe
static int bcf_dec_typed_int1_safe(uint8_t *p, uint8_t *end, uint8_t **q,
                                   int32_t *val) {
    uint32_t t;
    if (end - p < 2) return -1;
    t = *p++ & 0xf;
    /* Use if .. else if ... else instead of switch to force order.  Assumption
       is that small integers are more frequent than big ones. */
    if (t == BCF_BT_INT8) {
        *val = *(int8_t *) p++;
    } else {
        if (end - p < (1<<bcf_type_shift[t])) return -1;
        if (t == BCF_BT_INT16) {
            *val = le_to_i16(p);
            p += 2;
        } else if (t == BCF_BT_INT32) {
            *val = le_to_i32(p);
            p += 4;
#ifdef VCF_ALLOW_INT64
        } else if (t == BCF_BT_INT64) {
            // This case should never happen because there should be no
            // 64-bit BCFs at all, definitely not coming from htslib
            *val = le_to_i64(p);
            p += 8;
#endif
        } else {
            return -1;
        }
    }
    *q = p;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jge 0x52045
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5211f
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
andl $0xf, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jne 0x52080
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x5210d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
leaq 0xd35b9(%rip), %rcx     # 0x125650
movzbl (%rcx,%rdx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x520b5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5211f
cmpl $0x2, -0x2c(%rbp)
jne 0x520db
movq -0x10(%rbp), %rdi
callq 0x45390
movswl %ax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0x5210b
cmpl $0x3, -0x2c(%rbp)
jne 0x52100
movq -0x10(%rbp), %rdi
callq 0x453e0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x52109
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5211f
jmp 0x5210b
jmp 0x5210d
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_record_check_err
static void bcf_record_check_err(const bcf_hdr_t *hdr, bcf1_t *rec,
                                 char *type, uint32_t *reports, int i) {
    if (*reports == 0 || hts_verbose >= HTS_LOG_DEBUG)
        hts_log_warning("Bad BCF record at %s:%"PRIhts_pos
                        ": Invalid FORMAT %s %d",
                        bcf_seqname_safe(hdr,rec), rec->pos+1, type, i);
    (*reports)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x52161
leaq 0xd33b4(%rip), %rax     # 0x125510
cmpl $0x5, (%rax)
jl 0x521a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %r8
addq $0x1, %r8
movq -0x18(%rbp), %r9
movl -0x24(%rbp), %eax
movl $0x3, %edi
leaq 0xb680c(%rip), %rsi     # 0x10899b
leaq 0xb681a(%rip), %rdx     # 0x1089b0
movl %eax, (%rsp)
movb $0x0, %al
callq 0x9d90
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf1_sync_alleles
static inline int bcf1_sync_alleles(bcf1_t *line, kstring_t *str)
{
    // list of typed strings
    int i;
    for (i=0; i<line->n_allele; i++) {
        if (bcf_enc_vchar(str, strlen(line->d.allele[i]), line->d.allele[i]) < 0)
            return -1;
    }
    if ( !line->rlen && line->n_allele ) line->rlen = strlen(line->d.allele[0]);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
cmpl %ecx, %eax
jge 0x522ca
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x41a0
movq -0x28(%rbp), %rdi
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x44db0
cmpl $0x0, %eax
jge 0x522bd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x52311
jmp 0x522bf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x52257
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5230a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpl $0x0, %eax
je 0x5230a
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq (%rax), %rdi
callq 0x41a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: vcf_parse_format_empty1
static int vcf_parse_format_empty1(kstring_t *s, const bcf_hdr_t *h, bcf1_t *v,
                                   const char *p, const char *q) {
    const char *end = s->s + s->l;
    if ( q>=end )
    {
        hts_log_error("FORMAT column with no sample columns starting at %s:%"PRIhts_pos"", bcf_seqname_safe(h,v), v->pos+1);
        v->errcode |= BCF_ERR_NCOLS;
        return -1;
    }

    v->n_fmt = 0;
    if ( p[0]=='.' && p[1]==0 ) // FORMAT field is empty "."
    {
        v->n_sample = bcf_hdr_nsamples(h);
        return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x52c7a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43520
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %r8
addq $0x1, %r8
movl $0x1, %edi
leaq 0xb5f92(%rip), %rsi     # 0x108be2
leaq 0xb5fa3(%rip), %rdx     # 0x108bfa
movb $0x0, %al
callq 0x9d90
movq -0x20(%rbp), %rax
movl 0xcc(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0xcc(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x52cef
movq -0x20(%rbp), %rax
movabsq $-0xff00000001, %rcx    # imm = 0xFFFFFF00FFFFFFFF
andq 0x18(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x52ce8
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x52ce8
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x18(%rax), %rcx
andq $0xffffff, %rdx         # imm = 0xFFFFFF
shlq $0x28, %rdx
movabsq $0xffffffffff, %rsi     # imm = 0xFFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x52cef
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: vcf_parse_format_check7
static int vcf_parse_format_check7(const bcf_hdr_t *h, bcf1_t *v) {
    if ( v->n_sample!=bcf_hdr_nsamples(h) )
    {
        hts_log_error("Number of columns at %s:%"PRIhts_pos" does not match the number of samples (%d vs %d)",
            bcf_seqname_safe(h,v), v->pos+1, v->n_sample, bcf_hdr_nsamples(h));
        v->errcode |= BCF_ERR_NCOLS;
        return -1;
    }
    if ( v->indiv.l > 0xffffffff )
    {
        hts_log_error("The FORMAT at %s:%"PRIhts_pos" is too long", bcf_seqname_safe(h,v), v->pos+1);
        v->errcode |= BCF_ERR_LIMITS;

        // Error recovery: return -1 if this is a critical error or 0 if we want to ignore the FORMAT and proceed
        v->n_fmt = 0;
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x28, %rax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x54d62
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43520
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %r8
addq $0x1, %r8
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x28, %rax
movl %eax, %r9d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x1, %edi
leaq 0xb42ff(%rip), %rsi     # 0x109031
leaq 0xb4310(%rip), %rdx     # 0x109049
movl %eax, (%rsp)
movb $0x0, %al
callq 0x9d90
movq -0x18(%rbp), %rax
movl 0xcc(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0xcc(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54de3
movq -0x18(%rbp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, 0x38(%rax)
jbe 0x54ddc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43520
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %r8
addq $0x1, %r8
movl $0x1, %edi
leaq 0xb4299(%rip), %rsi     # 0x109031
leaq 0xb42f6(%rip), %rdx     # 0x109095
movb $0x0, %al
callq 0x9d90
movq -0x18(%rbp), %rax
movl 0xcc(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0xcc(%rax)
movq -0x18(%rbp), %rax
movabsq $-0xff00000001, %rcx    # imm = 0xFFFFFF00FFFFFFFF
andq 0x18(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x18(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54de3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: align_mem
static inline int align_mem(kstring_t *s)
{
    int e = 0;
    if (s->l&7) {
        uint64_t zero = 0;
        e = kputsn((char*)&zero, 8 - (s->l&7), s) < 0;
    }
    return e == 0 ? 0 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x54e4a
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
movl $0x8, %esi
subq %rax, %rsi
movq -0x8(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x43970
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/tbx.c
// Function: get_tid
static inline int get_tid(tbx_t *tbx, const char *ss, int is_add)
{
    khint_t k;
    khash_t(s2i) *d;
    if ((tbx->conf.preset&0xffff) == TBX_GAF) return(0);
    if (tbx->dict == 0) tbx->dict = kh_init(s2i);
    if (!tbx->dict) return -1; // Out of memory
    d = (khash_t(s2i)*)tbx->dict;
    if (is_add) {
        int absent;
        k = kh_put(s2i, d, ss, &absent);
        if (absent < 0) {
            return -1; // Out of memory
        } else if (absent) {
            char *ss_dup = strdup(ss);
            if (ss_dup) {
                kh_key(d, k) = ss_dup;
                kh_val(d, k) = kh_size(d) - 1;
            } else {
                kh_del(s2i, d, k);
                return -1; // Out of memory
            }
        }
    } else k = kh_get(s2i, d, ss);
    return k == kh_end(d)? -1 : kh_val(d, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cmpl $0x3, %eax
jne 0xf07bf
movl $0x0, -0x4(%rbp)
jmp 0xf08d6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xf07da
callq 0x60f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xf07f1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf08d6
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xf0894
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x6890
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0xf082d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf08d6
cmpl $0x0, -0x2c(%rbp)
je 0xf0890
movq -0x18(%rbp), %rdi
callq 0x4920
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xf0879
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x20(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x20(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0xf088e
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x6bf0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf08d6
jmp 0xf0890
jmp 0xf0892
jmp 0xf08a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x61e0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xf08bc
movq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xf08cf
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/tbx.c
// Function: tbx_readrec
int tbx_readrec(BGZF *fp, void *tbxv, void *sv, int *tid, hts_pos_t *beg, hts_pos_t *end)
{
    tbx_t *tbx = (tbx_t *) tbxv;
    kstring_t *s = (kstring_t *) sv;
    int ret;
    if ((ret = bgzf_getline(fp, '\n', s)) >= 0) {
        tbx_intv_t intv;
        if (get_intv(tbx, s, &intv, 0) < 0)
            return -2;
        *tid = intv.tid; *beg = intv.beg; *end = intv.end;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rdx
movl $0xa, %esi
callq 0xdc1e0
movl %eax, -0x4c(%rbp)
cmpl $0x0, %eax
jl 0xf16fd
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdx
xorl %ecx, %ecx
callq 0xf1710
cmpl $0x0, %eax
jge 0xf16de
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xf1703
movl -0x58(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x78(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x70(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/tbx.c
// Function: adjust_max_ref_len_sam
static void adjust_max_ref_len_sam(const char *str, int64_t *max_ref_len)
{
    const char *ptr;
    int64_t len;
    if (strncmp(str, "@SQ", 3) != 0) return;
    ptr = strstr(str + 3, "\tLN:");
    if (!ptr) return;
    ptr += 4;
    len = strtoll(ptr, NULL, 10);
    if (*max_ref_len < len) *max_ref_len = len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x143ff(%rip), %rsi     # 0x10606a
movl $0x3, %edx
callq 0x41f0
cmpl $0x0, %eax
je 0xf1c7c
jmp 0xf1cd7
movq -0x8(%rbp), %rdi
addq $0x3, %rdi
leaq 0x13b7f(%rip), %rsi     # 0x10580a
callq 0x40b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf1c9d
jmp 0xf1cd7
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x4090
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jge 0xf1cd7
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/tbx.c
// Function: adjust_max_ref_len_vcf
static void adjust_max_ref_len_vcf(const char *str, int64_t *max_ref_len)
{
    const char *ptr;
    int64_t len;
    if (strncmp(str, "##contig", 8) != 0) return;
    ptr = strstr(str + 8, "length");
    if (!ptr) return;
    for (ptr += 6; *ptr == ' ' || *ptr == '='; ptr++) {}
    len = strtoll(ptr, NULL, 10);
    if (*max_ref_len < len) *max_ref_len = len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1d6f7(%rip), %rsi     # 0x10f3f2
movl $0x8, %edx
callq 0x41f0
cmpl $0x0, %eax
je 0xf1d0f
jmp 0xf1da4
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x14b3c(%rip), %rsi     # 0x10685a
callq 0x40b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf1d30
jmp 0xf1da4
movq -0x18(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x21(%rbp)
je 0xf1d5d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xf1d66
jmp 0xf1d76
jmp 0xf1d68
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf1d3c
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x4090
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jge 0xf1da4
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/tbx.c
// Function: adjust_n_lvls
static int adjust_n_lvls(int min_shift, int n_lvls, int64_t max_len)
{
    int64_t s = hts_bin_maxpos(min_shift, n_lvls);
    max_len += 256;
    for (; max_len > s; ++n_lvls, s <<= 3) {}
    return n_lvls;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0xf2680
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0xf1e02
jmp 0xf1deb
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0xf1ddf
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/tbx.c
// Function: tbx_destroy
void tbx_destroy(tbx_t *tbx)
{
    khash_t(s2i) *d = (khash_t(s2i)*)tbx->dict;
    if (d != NULL)
    {
        khint_t k;
        for (k = kh_begin(d); k != kh_end(d); ++k)
            if (kh_exist(d, k)) free((char*)kh_key(d, k));
    }
    hts_idx_destroy(tbx->idx);
    kh_destroy(s2i, d);
    free(tbx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf20b9
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0xf20b7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xf20aa
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
jmp 0xf20ac
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf2066
jmp 0xf20b9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc2c0
movq -0x10(%rbp), %rdi
callq 0x6110
movq -0x8(%rbp), %rdi
callq 0x45a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/tbx.c
// Function: tbx_index_build3
int tbx_index_build3(const char *fn, const char *fnidx, int min_shift, int n_threads, const tbx_conf_t *conf)
{
    tbx_t *tbx;
    BGZF *fp;
    int ret;
    if ((fp = bgzf_open(fn, "r")) == 0) return -1;
    if ( n_threads ) bgzf_mt(fp, n_threads, 256);
    if ( bgzf_compression(fp) != bgzf ) { bgzf_close(fp); return -2; }
    tbx = tbx_index(fp, min_shift, conf);
    bgzf_close(fp);
    if ( !tbx ) return -1;
    ret = hts_idx_save_as(tbx->idx, fn, fnidx, min_shift > 0? HTS_FMT_CSI : HTS_FMT_TBI);
    tbx_destroy(tbx);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1436b(%rip), %rsi     # 0x106470
callq 0xd7330
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xf2120
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf21bd
cmpl $0x0, -0x20(%rbp)
je 0xf2137
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %esi
movl $0x100, %edx            # imm = 0x100
callq 0xdaa10
movq -0x38(%rbp), %rdi
callq 0xdc080
cmpl $0x2, %eax
je 0xf2157
movq -0x38(%rbp), %rdi
callq 0xdb670
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xf21bd
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0xf18e0
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
callq 0xdb670
cmpq $0x0, -0x30(%rbp)
jne 0xf2184
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf21bd
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %r8d
movl $0x2, %ecx
xorl %eax, %eax
cmpl $0x0, %r8d
cmovgl %eax, %ecx
callq 0xf1c0
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
callq 0xf2040
movl -0x3c(%rbp), %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/tbx.c
// Function: tbx_seqnames
const char **tbx_seqnames(tbx_t *tbx, int *n)
{
    khash_t(s2i) *d = (khash_t(s2i)*)tbx->dict;
    if (d == NULL)
    {
        *n = 0;
        return calloc(1, sizeof(char *));
    }
    int tid, m = kh_size(d);
    const char **names = (const char**) calloc(m,sizeof(const char*));
    khint_t k;
    if (!names) {
        *n = 0;
        return NULL;
    }
    for (k=kh_begin(d); k<kh_end(d); k++)
    {
        if ( !kh_exist(d,k) ) continue;
        tid = kh_val(d,k);
        assert( tid<m );
        names[tid] = kh_key(d,k);
    }
    // sanity check: there should be no gaps
    for (tid=0; tid<m; tid++)
        assert(names[tid]);
    *n = m;
    return names;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf2535
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, %edi
movl $0x8, %esi
callq 0x42e0
movq %rax, -0x8(%rbp)
jmp 0xf266d
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x42e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xf256f
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xf266d
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xf2610
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x34(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x34(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xf25ac
jmp 0xf2602
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xf25c8
jmp 0xf25e7
leaq 0x1cd1e(%rip), %rdi     # 0x10f2ed
leaq 0x1cd1d(%rip), %rsi     # 0x10f2f3
movl $0x271, %edx            # imm = 0x271
leaq 0x1cd17(%rip), %rcx     # 0x10f2f9
callq 0x42d0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xf2576
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xf265c
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xf2630
jmp 0xf264f
leaq 0x1ccec(%rip), %rdi     # 0x10f323
leaq 0x1ccb5(%rip), %rsi     # 0x10f2f3
movl $0x276, %edx            # imm = 0x276
leaq 0x1ccaf(%rip), %rcx     # 0x10f2f9
callq 0x42d0
jmp 0xf2651
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xf2617
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%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/OhYee[P]computer_application_programming_experiment/utils/thread/test/test_thread.c
// Function: generator
int generator() {
    int value = -1;

    if (counter < 20) {
        value = counter++;
    }

    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
cmpl $0x14, 0x257e(%rip)     # 0x40b0
jge 0x1b48
movl 0x2576(%rip), %eax      # 0x40b0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x256b(%rip)      # 0x40b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/utils/thread/test/test_thread.c
// Function: task
void *task(void *args) {
    thread_pool *tp = args;

    for (;;) {
        tp_lock(tp, 0);
        int number = generator();
        tp_unlock(tp, 0);

        tp_lock(tp, 1);
        write(number);
        tp_unlock(tp, 1);

        if (number == -1) {
            return NULL;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1690
callq 0x1b20
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x16e0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1690
movl -0x14(%rbp), %edi
callq 0x1b50
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x16e0
cmpl $-0x1, -0x14(%rbp)
jne 0x1be4
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x1b94
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/utils/thread/test/test_thread.c
// Function: main
int main() {
    boolean pass = T;
    mp_init(1 << 16, mp_exit);
    thread_pool *tp = tp_new(3, 2, task);
    tp_wait(tp);

    int got = generator(tp);
    if (got != -1) {
        print_err("generator should be -1, but got %d\n", got);
        pass = F;
    }
    for (int i = 0; i < 20; ++i) {
        if (i != res[i]) {
            print_err("res[%d] excepted %d, got %d\n", i, i, res[i]);
            pass = F;
        }
    }
    if (pass) {
        print_ok("All test case passed!\n");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x3fe(%rip), %rax       # 0x2004
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movl $0x10000, %edi          # imm = 0x10000
leaq -0x4e7(%rip), %rsi      # 0x1730
callq 0x1740
movl $0x3, %edi
movl $0x2, %esi
leaq -0xad(%rip), %rdx       # 0x1b80
callq 0x14f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1620
movq -0x10(%rbp), %rdi
movb $0x0, %al
callq 0x1b20
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x1c70
movl -0x14(%rbp), %esi
leaq 0x558(%rip), %rdi       # 0x21b5
movb $0x0, %al
callq 0x1370
leaq 0x39d(%rip), %rax       # 0x2008
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x14, -0x18(%rbp)
jge 0x1ccb
movl -0x18(%rbp), %eax
movslq -0x18(%rbp), %rdx
leaq 0x2435(%rip), %rcx      # 0x40c0
cmpl (%rcx,%rdx,4), %eax
je 0x1cbe
movl -0x18(%rbp), %esi
movl -0x18(%rbp), %edx
movslq -0x18(%rbp), %rcx
leaq 0x241f(%rip), %rax      # 0x40c0
movl (%rax,%rcx,4), %ecx
leaq 0x52e(%rip), %rdi       # 0x21d9
movb $0x0, %al
callq 0x1370
leaq 0x34f(%rip), %rax       # 0x2008
movl (%rax), %eax
movl %eax, -0x8(%rbp)
jmp 0x1cc0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c77
cmpl $0x0, -0x8(%rbp)
je 0x1cdf
leaq 0x51e(%rip), %rdi       # 0x21f6
movb $0x0, %al
callq 0x1430
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_03/expand.c
// Function: main
int main(void)
{
  char str[MAXLEN];
  char expanded_str[MAXLEN];

  get_str(str, MAXLEN);
  expand(str, expanded_str);
  printf("%s", expanded_str);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e30, %rsp           # imm = 0x4E30
movl $0x0, -0x4(%rbp)
leaq -0x2720(%rbp), %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x11c0
leaq -0x2720(%rbp), %rdi
leaq -0x4e30(%rbp), %rsi
callq 0x1240
leaq -0x4e30(%rbp), %rsi
leaq 0xe60(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x4e30, %rsp           # imm = 0x4E30
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_destsrc
int op_destsrc (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    uint8_t *t    = d+1;
    int      attr = *t++;
    out += sprintf  (out, "%-5s  ", op->name);
    t   += sub_dest (t, out, op->desttype, attr >> 6, size_align[(attr & 0x38)>>3], op->destindex);
    out += strlen   (out);
    out += sprintf  (out, "  <-  ");
    t   += sub_src  (t, out, attr & 0x07, (attr & 0x38) >> 3, size_align[(attr & 0x38)>>3], op->srcindex);
    return t - d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5dac0(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x4810a(%rip), %rsi     # 0x4c459
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movl -0x24(%rbp), %ecx
sarl $0x6, %ecx
movl -0x24(%rbp), %eax
andl $0x38, %eax
sarl $0x3, %eax
movslq %eax, %r8
leaq 0x47d62(%rip), %rax     # 0x4c0f0
movl (%rax,%r8,4), %r8d
movq -0x18(%rbp), %rax
movl 0x18(%rax), %r9d
callq 0x5270
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4070
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x48061(%rip), %rsi     # 0x4c42c
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
andl $0x7, %edx
movl -0x24(%rbp), %ecx
andl $0x38, %ecx
sarl $0x3, %ecx
movl -0x24(%rbp), %eax
andl $0x38, %eax
sarl $0x3, %eax
movslq %eax, %r8
leaq 0x47ce4(%rip), %rax     # 0x4c0f0
movl (%rax,%r8,4), %r8d
movq -0x18(%rbp), %rax
movl 0x14(%rax), %r9d
callq 0x54f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikebdp2[P]AtomDis/main.c
// Function: op_shift
int op_shift (uint8_t *d, char *out) {
    const optab_t *op = &optable[d[0]];
    uint8_t *t    = d+1;
    int      attr = *t++;
    out += sprintf  (out, "%-5s  ", op->name);
    t   += sub_src (t, out, op->desttype, (attr & 0x38) >> 3, size_align[(attr & 0x38)>>3], op->destindex);
    out += strlen   (out);
    out += sprintf  (out, "  by  %02x", *t++);
    return t - d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x5d970(%rip), %rax     # 0x61dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x47fba(%rip), %rsi     # 0x4c459
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movl -0x24(%rbp), %ecx
andl $0x38, %ecx
sarl $0x3, %ecx
movl -0x24(%rbp), %eax
andl $0x38, %eax
sarl $0x3, %eax
movslq %eax, %r8
leaq 0x47c0f(%rip), %rax     # 0x4c0f0
movl (%rax,%r8,4), %r8d
movq -0x18(%rbp), %rax
movl 0x18(%rax), %r9d
callq 0x54f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4070
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %edx
leaq 0x47f03(%rip), %rsi     # 0x4c433
movb $0x0, %al
callq 0x41b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)