LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./sam_internal.h
// Function: nibble2base_default
static inline void nibble2base_default(uint8_t *nib, char *seq, int len) {
    static const char code2base[512] =
        "===A=C=M=G=R=S=V=T=W=Y=H=K=D=B=N"
        "A=AAACAMAGARASAVATAWAYAHAKADABAN"
        "C=CACCCMCGCRCSCVCTCWCYCHCKCDCBCN"
        "M=MAMCMMMGMRMSMVMTMWMYMHMKMDMBMN"
        "G=GAGCGMGGGRGSGVGTGWGYGHGKGDGBGN"
        "R=RARCRMRGRRRSRVRTRWRYRHRKRDRBRN"
        "S=SASCSMSGSRSSSVSTSWSYSHSKSDSBSN"
        "V=VAVCVMVGVRVSVVVTVWVYVHVKVDVBVN"
        "T=TATCTMTGTRTSTVTTTWTYTHTKTDTBTN"
        "W=WAWCWMWGWRWSWVWTWWWYWHWKWDWBWN"
        "Y=YAYCYMYGYRYSYVYTYWYYYHYKYDYBYN"
        "H=HAHCHMHGHRHSHVHTHWHYHHHKHDHBHN"
        "K=KAKCKMKGKRKSKVKTKWKYKHKKKDKBKN"
        "D=DADCDMDGDRDSDVDTDWDYDHDKDDDBDN"
        "B=BABCBMBGBRBSBVBTBWBYBHBKBDBBBN"
        "N=NANCNMNGNRNSNVNTNWNYNHNKNDNBNN";

    int i, len2 = len/2;
    seq[0] = 0;

    for (i = 0; i < len2; i++)
        // Note size_t cast helps gcc optimiser.
        memcpy(&seq[i*2], &code2base[(size_t)nib[i]*2], 2);

    if ((i *= 2) < len)
        seq[i] = seq_nt16_str[bam_seqi(nib, i)];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4afaa
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movq -0x8(%rbp), %rdx
movslq -0x18(%rbp), %rsi
movzbl (%rdx,%rsi), %edx
movl %edx, %esi
shlq %rsi
leaq 0xa80e9(%rip), %rdx     # 0xf3080
movw (%rdx,%rsi), %dx
movw %dx, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4af6b
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
cmpl -0x14(%rbp), %eax
jge 0x4aff0
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl -0x18(%rbp), %ecx
xorl $-0x1, %ecx
andl $0x1, %ecx
shll $0x2, %ecx
sarl %cl, %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0xa4c4e(%rip), %rax     # 0xefc30
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/textutils.c
// Function: hts_decode_percent
int hts_decode_percent(char *dest, size_t *destlen, const char *s)
{
    char *d = dest;
    int hi, lo;

    while (*s) {
        if (*s == '%' && (hi = dehex(s[1])) >= 0 && (lo = dehex(s[2])) >= 0) {
            *d++ = (hi << 4) | lo;
            s += 3;
        }
        else *d++ = *s++;
    }

    *d = '\0';
    *destlen = d - dest;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4b5c0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x4b599
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x4b5f0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jl 0x4b599
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %edi
callq 0x4b5f0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jl 0x4b599
movl -0x24(%rbp), %eax
shll $0x4, %eax
orl -0x28(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x4b5bb
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x4b52c
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/textutils.c
// Function: dehex
static int dehex(char c)
{
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    else if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    else if (c >= '0' && c <= '9') return c - '0';
    else return -1;  // Hence dehex('\0') = -1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x4b61b
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x4b61b
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x4b661
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x4b63c
movsbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x4b63c
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x4b661
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x4b65a
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x4b65a
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x4b661
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/textutils.c
// Function: hts_decode_base64
int hts_decode_base64(char *dest, size_t *destlen, const char *s)
{
    char *d = dest;
    int x0, x1, x2, x3;

    while (1) {
        x0 = debase64(*s++);
        x1 = (x0 >= 0)? debase64(*s++) : -1;
        x2 = (x1 >= 0)? debase64(*s++) : -1;
        x3 = (x2 >= 0)? debase64(*s++) : -1;
        if (x3 < 0) break;

        *d++ = (x0 << 2) | (x1 >> 4);
        *d++ = (x1 << 4) | (x2 >> 2);
        *d++ = (x2 << 6) | x3;
    }

    if (x1 >= 0) *d++ = (x0 << 2) | (x1 >> 4);
    if (x2 >= 0) *d++ = (x1 << 4) | (x2 >> 2);

    *destlen = d - dest;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %edi
callq 0x4b830
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x4b6e8
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %edi
callq 0x4b830
movl %eax, -0x34(%rbp)
jmp 0x4b6f2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x4b6f2
movl -0x34(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x4b71a
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %edi
callq 0x4b830
movl %eax, -0x38(%rbp)
jmp 0x4b724
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x38(%rbp)
jmp 0x4b724
movl -0x38(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x4b74c
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %edi
callq 0x4b830
movl %eax, -0x3c(%rbp)
jmp 0x4b756
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x3c(%rbp)
jmp 0x4b756
movl -0x3c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x4b764
jmp 0x4b7c7
movl -0x24(%rbp), %eax
shll $0x2, %eax
movl -0x28(%rbp), %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x28(%rbp), %eax
shll $0x4, %eax
movl -0x2c(%rbp), %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
shll $0x6, %eax
orl -0x30(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x4b6ac
cmpl $0x0, -0x28(%rbp)
jl 0x4b7ee
movl -0x24(%rbp), %eax
shll $0x2, %eax
movl -0x28(%rbp), %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
cmpl $0x0, -0x2c(%rbp)
jl 0x4b815
movl -0x28(%rbp), %eax
shll $0x4, %eax
movl -0x2c(%rbp), %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/textutils.c
// Function: debase64
static int debase64(char c)
{
    if (c >= 'a' && c <= 'z') return c - 'a' + 26;
    else if (c >= 'A' && c <= 'Z') return c - 'A';
    else if (c >= '0' && c <= '9') return c - '0' + 52;
    else if (c == '/') return 63;
    else if (c == '+') return 62;
    else return -1;  // Hence debase64('\0') = -1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x4b85b
movsbl -0x5(%rbp), %eax
cmpl $0x7a, %eax
jg 0x4b85b
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0x1a, %eax
movl %eax, -0x4(%rbp)
jmp 0x4b8c5
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x4b879
movsbl -0x5(%rbp), %eax
cmpl $0x5a, %eax
jg 0x4b879
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
movl %eax, -0x4(%rbp)
jmp 0x4b8c5
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x4b89a
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x4b89a
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
addl $0x34, %eax
movl %eax, -0x4(%rbp)
jmp 0x4b8c5
movsbl -0x5(%rbp), %eax
cmpl $0x2f, %eax
jne 0x4b8ac
movl $0x3f, -0x4(%rbp)
jmp 0x4b8c5
movsbl -0x5(%rbp), %eax
cmpl $0x2b, %eax
jne 0x4b8be
movl $0x3e, -0x4(%rbp)
jmp 0x4b8c5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/textutils.c
// Function: token_type
static char token_type(hts_json_token *token)
{
    const char *s = token->str;

    switch (*s) {
    case 'f':
        return (strcmp(s, "false") == 0)? 'b' : '?';
    case 'n':
        return (strcmp(s, "null") == 0)? '.' : '?';
    case 't':
        return (strcmp(s, "true") == 0)? 'b' : '?';
    case '-':
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
        return 'n';
    default:
        return '?';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $-0x2d, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x47, %eax
ja 0x4bec0
movq -0x20(%rbp), %rax
leaq 0xa7444(%rip), %rcx     # 0xf3280
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
leaq 0xa5231(%rip), %rsi     # 0xf1081
callq 0x4690
movl %eax, %edx
movl $0x3f, %eax
movl $0x62, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movb %al, -0x1(%rbp)
jmp 0x4bec4
movq -0x18(%rbp), %rdi
leaq 0xa758d(%rip), %rsi     # 0xf3404
callq 0x4690
movl %eax, %edx
movl $0x3f, %eax
movl $0x2e, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movb %al, -0x1(%rbp)
jmp 0x4bec4
movq -0x18(%rbp), %rdi
leaq 0xa756b(%rip), %rsi     # 0xf3409
callq 0x4690
movl %eax, %edx
movl $0x3f, %eax
movl $0x62, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movb %al, -0x1(%rbp)
jmp 0x4bec4
movb $0x6e, -0x1(%rbp)
jmp 0x4bec4
movb $0x3f, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/textutils.c
// Function: skip_value
static char skip_value(char type, hts_json_nextfn *next, void *arg1, void *arg2)
{
    hts_json_token token;
    int level;

    switch (type? type : next(arg1, arg2, &token)) {
    case '\0':
        return '\0';

    case '?':
    case '}':
    case ']':
        return '?';

    case '{':
    case '[':
        level = 1;
        break;

    default:
        return 'v';
    }

    while (level > 0)
        switch (next(arg1, arg2, &token)) {
        case '\0':
            return '\0';

        case '?':
            return '?';

        case '{':
        case '[':
            level++;
            break;

        case '}':
        case ']':
            --level;
            break;

        default:
            break;
        }

    return 'v';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x0, %eax
je 0x4c53c
movsbl -0x2(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x4c554
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq *%rax
movsbl %al, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x4c592
jmp 0x4c560
movl -0x3c(%rbp), %eax
subl $0x3f, %eax
je 0x4c59b
jmp 0x4c56a
movl -0x3c(%rbp), %eax
subl $0x5b, %eax
je 0x4c5a4
jmp 0x4c574
movl -0x3c(%rbp), %eax
subl $0x5d, %eax
je 0x4c59b
jmp 0x4c57e
movl -0x3c(%rbp), %eax
subl $0x7b, %eax
je 0x4c5a4
jmp 0x4c588
movl -0x3c(%rbp), %eax
subl $0x7d, %eax
je 0x4c59b
jmp 0x4c5ad
movb $0x0, -0x1(%rbp)
jmp 0x4c638
movb $0x3f, -0x1(%rbp)
jmp 0x4c638
movl $0x1, -0x34(%rbp)
jmp 0x4c5b6
movb $0x76, -0x1(%rbp)
jmp 0x4c638
jmp 0x4c5b8
cmpl $0x0, -0x34(%rbp)
jle 0x4c634
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq *%rax
movsbl %al, %eax
movl %eax, -0x40(%rbp)
testl %eax, %eax
je 0x4c60e
jmp 0x4c5dc
movl -0x40(%rbp), %eax
subl $0x3f, %eax
je 0x4c614
jmp 0x4c5e6
movl -0x40(%rbp), %eax
subl $0x5b, %eax
je 0x4c61a
jmp 0x4c5f0
movl -0x40(%rbp), %eax
subl $0x5d, %eax
je 0x4c625
jmp 0x4c5fa
movl -0x40(%rbp), %eax
subl $0x7b, %eax
je 0x4c61a
jmp 0x4c604
movl -0x40(%rbp), %eax
subl $0x7d, %eax
je 0x4c625
jmp 0x4c630
movb $0x0, -0x1(%rbp)
jmp 0x4c638
movb $0x3f, -0x1(%rbp)
jmp 0x4c638
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4c632
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4c632
jmp 0x4c632
jmp 0x4c5b8
movb $0x76, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/textutils.c
// Function: hts_json_fskip_value
HTSLIB_EXPORT
char hts_json_fskip_value(struct hFILE *fp, char type)
{
    kstring_t str = { 0, 0, NULL };
    char ret = skip_value(type, fnext, fp, &str);
    free(str.s);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4250
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0x30(%rip), %rsi        # 0x4c6e0
leaq -0x28(%rbp), %rcx
movsbl %al, %edi
callq 0x4c510
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45a0
movb -0x29(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/textutils.c
// Function: stringify_argv
char *stringify_argv(int argc, char *argv[]) {
    char *str, *cp;
    size_t nbytes = 1;
    int i, j;

    /* Allocate */
    for (i = 0; i < argc; i++) {
        if (i > 0) nbytes += 1;
        nbytes += strlen(argv[i]);
    }
    if (!(str = malloc(nbytes)))
        return NULL;

    /* Copy */
    cp = str;
    for (i = 0; i < argc; i++) {
        if (i > 0) *cp++ = ' ';
        j = 0;
        while (argv[i][j]) {
            if (argv[i][j] == '\t')
                *cp++ = ' ';
            else
                *cp++ = argv[i][j];
            j++;
        }
    }
    *cp++ = 0;

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x1, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4c76c
cmpl $0x0, -0x34(%rbp)
jle 0x4c748
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x41b0
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4c72e
movq -0x30(%rbp), %rdi
callq 0x4650
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4c78c
movq $0x0, -0x8(%rbp)
jmp 0x4c862
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4c848
cmpl $0x0, -0x34(%rbp)
jle 0x4c7bf
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x20, (%rax)
movl $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4c838
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x4c809
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x20, (%rax)
jmp 0x4c82d
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4c7c6
jmp 0x4c83a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4c79b
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/textutils.c
// Function: encode_utf8
static char *encode_utf8(char *s, unsigned x)
{
    if (x >= 0x10000) {
        *s++ = 0xF0 | (x >> 18);
        *s++ = 0x80 | ((x >> 12) & 0x3F);
        *s++ = 0x80 | ((x >> 6) & 0x3F);
        *s++ = 0x80 | (x & 0x3F);
    }
    else if (x >= 0x800) {
        *s++ = 0xE0 | (x >> 12);
        *s++ = 0x80 | ((x >> 6) & 0x3F);
        *s++ = 0x80 | (x & 0x3F);
    }
    else if (x >= 0x80) {
        *s++ = 0xC0 | (x >> 6);
        *s++ = 0x80 | (x & 0x3F);
    }
    else *s++ = x;

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jb 0x4cbdb
movl -0xc(%rbp), %eax
shrl $0x12, %eax
orl $0xf0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0xc, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x4cca4
cmpl $0x800, -0xc(%rbp)      # imm = 0x800
jb 0x4cc43
movl -0xc(%rbp), %eax
shrl $0xc, %eax
orl $0xe0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x4cca2
cmpl $0x80, -0xc(%rbp)
jb 0x4cc8a
movl -0xc(%rbp), %eax
shrl $0x6, %eax
orl $0xc0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x4cca0
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x4cca2
jmp 0x4cca4
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_worker_id
int hts_tpool_worker_id(hts_tpool *p) {
    if (!p)
        return -1;
    pthread_t s = pthread_self();
    int i;
    for (i = 0; i < p->tsize; i++) {
        if (pthread_equal(s, p->t[i].tid))
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4cd6c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4cdc9
callq 0x43f0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4cdc2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x48b0
cmpl $0x0, %eax
je 0x4cdb5
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4cdc9
jmp 0x4cdb7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4cd7c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_next_result
hts_tpool_result *hts_tpool_next_result(hts_tpool_process *q) {
    hts_tpool_result *r;

    DBG_OUT(stderr, "Requesting next result on queue %p\n", q);

    pthread_mutex_lock(&q->p->pool_m);
    r = hts_tpool_next_result_locked(q);
    pthread_mutex_unlock(&q->p->pool_m);

    DBG_OUT(stderr, "(q=%p) Found %p\n", q, r);

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x4cdee
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rdi
callq 0x4ce30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
jmp 0x4ce1d
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_next_result_locked
static hts_tpool_result *hts_tpool_next_result_locked(hts_tpool_process *q) {
    hts_tpool_result *r, *last;

    if (q->shutdown)
        return NULL;

    for (last = NULL, r = q->output_head; r; last = r, r = r->next) {
        if (r->serial == q->next_serial)
            break;
    }

    if (r) {
        // Remove r from out linked list
        if (q->output_head == r)
            q->output_head = r->next;
        else
            last->next = r->next;

        if (q->output_tail == r)
            q->output_tail = last;

        if (!q->output_head)
            q->output_tail = NULL;

        q->next_serial++;
        q->n_output--;

        if (q->qsize && q->n_output < q->qsize) {
            // Not technically input full, but can guarantee there is
            // room for the input to go somewhere so we still signal.
            // The waiting code will then check the condition again.
            if (q->n_input < q->qsize)
                pthread_cond_signal(&q->input_not_full_c);
            if (!q->shutdown)
                wake_next_worker(q, 1);
        }
    }

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x4ce53
movq $0x0, -0x8(%rbp)
jmp 0x4cf7d
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4ce99
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x4ce82
jmp 0x4ce99
jmp 0x4ce84
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4ce67
cmpq $0x0, -0x18(%rbp)
je 0x4cf75
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x4cec3
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x4ced1
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x4ceeb
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x4cf02
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x48(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x48(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x4cf73
movq -0x10(%rbp), %rax
movl 0x48(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x4cf73
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x4cf59
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x4040
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x4cf71
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4e590
jmp 0x4cf73
jmp 0x4cf75
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_next_result_wait
hts_tpool_result *hts_tpool_next_result_wait(hts_tpool_process *q) {
    hts_tpool_result *r;

    pthread_mutex_lock(&q->p->pool_m);
    while (!(r = hts_tpool_next_result_locked(q))) {
        /* Possible race here now avoided via _locked() call, but in case... */
        struct timeval now;
        struct timespec timeout;

        gettimeofday(&now, NULL);
        timeout.tv_sec = now.tv_sec + 10;
        timeout.tv_nsec = now.tv_usec * 1000;

        q->ref_count++;
        if (q->shutdown) {
            int rc = --q->ref_count;
            pthread_mutex_unlock(&q->p->pool_m);
            if (rc == 0)
                hts_tpool_process_destroy(q);
            return NULL;
        }
        pthread_cond_timedwait(&q->output_avail_c, &q->p->pool_m, &timeout);

        q->ref_count--;
    }
    pthread_mutex_unlock(&q->p->pool_m);

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x10(%rbp), %rdi
callq 0x4ce30
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4cfcb
jmp 0x4d06e
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x47f0
movq -0x28(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x38(%rbp)
imulq $0x3e8, -0x20(%rbp), %rax # imm = 0x3E8
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x4d040
movq -0x10(%rbp), %rcx
movl 0x5c(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x5c(%rcx)
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
cmpl $0x0, -0x3c(%rbp)
jne 0x4d036
movq -0x10(%rbp), %rdi
callq 0x4d090
movq $0x0, -0x8(%rbp)
jmp 0x4d086
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x38, %rsi
leaq -0x38(%rbp), %rdx
callq 0x4780
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x5c(%rax)
jmp 0x4cfac
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_destroy
void hts_tpool_process_destroy(hts_tpool_process *q) {
    DBG_OUT(stderr, "Destroying results queue %p\n", q);

    if (!q)
        return;

    // Prevent dispatch from queuing up any more jobs.
    // We want to reset (and flush) the queue here, before
    // we set the shutdown flag, but we need to avoid races
    // with queue more input during reset.
    pthread_mutex_lock(&q->p->pool_m);
    q->no_more_input = 1;
    pthread_mutex_unlock(&q->p->pool_m);

    // Ensure it's fully drained before destroying the queue
    hts_tpool_process_reset(q, 0);
    pthread_mutex_lock(&q->p->pool_m);
    hts_tpool_process_detach_locked(q->p, q);
    hts_tpool_process_shutdown_locked(q);

    // Maybe a worker is scanning this queue, so delay destruction
    if (--q->ref_count > 0) {
        pthread_mutex_unlock(&q->p->pool_m);
        return;
    }

    pthread_cond_destroy(&q->output_avail_c);
    pthread_cond_destroy(&q->input_not_full_c);
    pthread_cond_destroy(&q->input_empty_c);
    pthread_cond_destroy(&q->none_processing_c);
    pthread_mutex_unlock(&q->p->pool_m);

    free(q);

    DBG_OUT(stderr, "Destroyed results queue %p\n", q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x4d09e
cmpq $0x0, -0x8(%rbp)
jne 0x4d0aa
jmp 0x4d185
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4d720
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4d960
movq -0x8(%rbp), %rdi
callq 0x4d370
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x5c(%rcx)
cmpl $0x0, %eax
jle 0x4d12d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
jmp 0x4d185
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x49a0
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
callq 0x49a0
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0x49a0
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
callq 0x49a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
movq -0x8(%rbp), %rdi
callq 0x45a0
jmp 0x4d185
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_empty
int hts_tpool_process_empty(hts_tpool_process *q) {
    int empty;

    pthread_mutex_lock(&q->p->pool_m);
    empty = q->n_input == 0 && q->n_processing == 0 && q->n_output == 0;
    pthread_mutex_unlock(&q->p->pool_m);

    return empty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x44(%rcx)
movb %al, -0xd(%rbp)
jne 0x4d1d8
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x4c(%rcx)
movb %al, -0xd(%rbp)
jne 0x4d1d8
movq -0x8(%rbp), %rax
cmpl $0x0, 0x48(%rax)
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_ref_decr
void hts_tpool_process_ref_decr(hts_tpool_process *q) {
    pthread_mutex_lock(&q->p->pool_m);
    if (--q->ref_count <= 0) {
        pthread_mutex_unlock(&q->p->pool_m);
        hts_tpool_process_destroy(q);
        return;
    }

    // maybe also call destroy here if needed?
    pthread_mutex_unlock(&q->p->pool_m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x5c(%rcx)
cmpl $0x0, %eax
jg 0x4d289
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
movq -0x8(%rbp), %rdi
callq 0x4d090
jmp 0x4d299
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_len
int hts_tpool_process_len(hts_tpool_process *q) {
    int len;

    pthread_mutex_lock(&q->p->pool_m);
    len = q->n_output;
    pthread_mutex_unlock(&q->p->pool_m);

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_sz
int hts_tpool_process_sz(hts_tpool_process *q) {
    int len;

    pthread_mutex_lock(&q->p->pool_m);
    len = q->n_output + q->n_input + q->n_processing;
    pthread_mutex_unlock(&q->p->pool_m);

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x44(%rcx), %eax
movq -0x8(%rbp), %rcx
addl 0x4c(%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_shutdown_locked
static void hts_tpool_process_shutdown_locked(hts_tpool_process *q) {
    q->shutdown = 1;
    pthread_cond_broadcast(&q->output_avail_c);
    pthread_cond_broadcast(&q->input_not_full_c);
    pthread_cond_broadcast(&q->input_empty_c);
    pthread_cond_broadcast(&q->none_processing_c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x50(%rax)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x4150
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
callq 0x4150
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0x4150
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
callq 0x4150
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_is_shutdown
int hts_tpool_process_is_shutdown(hts_tpool_process *q) {
    pthread_mutex_lock(&q->p->pool_m);
    int r = q->shutdown;
    pthread_mutex_unlock(&q->p->pool_m);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_delete_result
void hts_tpool_delete_result(hts_tpool_result *r, int free_data) {
    if (!r)
        return;

    if (free_data && r->data)
        free(r->data);

    free(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4d428
jmp 0x4d44f
cmpl $0x0, -0xc(%rbp)
je 0x4d446
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4d446
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rdi
callq 0x45a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_init
hts_tpool_process *hts_tpool_process_init(hts_tpool *p, int qsize, int in_only) {
    hts_tpool_process *q = malloc(sizeof(*q));
    if (!q)
        return NULL;

    pthread_cond_init(&q->output_avail_c,   NULL);
    pthread_cond_init(&q->input_not_full_c, NULL);
    pthread_cond_init(&q->input_empty_c,    NULL);
    pthread_cond_init(&q->none_processing_c,NULL);

    q->p           = p;
    q->input_head  = NULL;
    q->input_tail  = NULL;
    q->output_head = NULL;
    q->output_tail = NULL;
    q->next_serial = 0;
    q->curr_serial = 0;
    q->no_more_input = 0;
    q->n_input     = 0;
    q->n_output    = 0;
    q->n_processing= 0;
    q->qsize       = qsize;
    q->in_only     = in_only;
    q->shutdown    = 0;
    q->wake_dispatch = 0;
    q->ref_count   = 1;

    q->next        = NULL;
    q->prev        = NULL;

    hts_tpool_process_attach(p, q);

    return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x130, %edi            # imm = 0x130
callq 0x4650
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4d4b4
movq $0x0, -0x8(%rbp)
jmp 0x4d5e8
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45b0
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45b0
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45b0
movq -0x20(%rbp), %rdi
addq $0xf0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45b0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4c(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x5c(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x120(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x128(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d600
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_attach
void hts_tpool_process_attach(hts_tpool *p, hts_tpool_process *q) {
    pthread_mutex_lock(&p->pool_m);
    if (p->q_head) {
        q->next = p->q_head;
        q->prev = p->q_head->prev;
        p->q_head->prev->next = q;
        p->q_head->prev = q;
    } else {
        q->next = q;
        q->prev = q;
    }
    p->q_head = q;
    assert(p->q_head && p->q_head->prev && p->q_head->next);
    pthread_mutex_unlock(&p->pool_m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4d684
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x120(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x128(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x128(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x128(%rax), %rax
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x128(%rax)
jmp 0x4d6a2
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x128(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4d6df
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x128(%rax)
je 0x4d6df
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x120(%rax)
je 0x4d6df
jmp 0x4d6fe
leaq 0xa5d28(%rip), %rdi     # 0xf340e
leaq 0xa5d51(%rip), %rsi     # 0xf343e
movl $0x1d4, %edx            # imm = 0x1D4
leaq 0xa5d53(%rip), %rcx     # 0xf344c
callq 0x42e0
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x4330
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_process_detach_locked
static void hts_tpool_process_detach_locked(hts_tpool *p,
                                            hts_tpool_process *q) {
    if (!p->q_head || !q->prev || !q->next)
        return;

    hts_tpool_process *curr = p->q_head, *first = curr;
    do {
        if (curr == q) {
            q->next->prev = q->prev;
            q->prev->next = q->next;
            p->q_head = q->next;
            q->next = q->prev = NULL;

            // Last one
            if (p->q_head == q)
                p->q_head = NULL;
            break;
        }

        curr = curr->next;
    } while (curr != first);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4d993
movq -0x10(%rbp), %rax
cmpq $0x0, 0x128(%rax)
je 0x4d993
movq -0x10(%rbp), %rax
cmpq $0x0, 0x120(%rax)
jne 0x4d998
jmp 0x4da5e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x4da41
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq %rcx, 0x128(%rax)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x128(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x120(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x4da3f
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x4da5e
movq -0x18(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x4d9ac
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_wake_dispatch
void hts_tpool_wake_dispatch(hts_tpool_process *q) {
    pthread_mutex_lock(&q->p->pool_m);
    q->wake_dispatch = 1;
    pthread_cond_signal(&q->input_not_full_c);
    pthread_mutex_unlock(&q->p->pool_m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rax
movl $0x1, 0x58(%rax)
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
callq 0x4040
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x4330
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_destroy
void hts_tpool_destroy(hts_tpool *p) {
    int i;

    DBG_OUT(stderr, "Destroying pool %p\n", p);

    /* Send shutdown message to worker threads */
    pthread_mutex_lock(&p->pool_m);
    p->shutdown = 1;

    DBG_OUT(stderr, "Sending shutdown request\n");

    for (i = 0; i < p->tsize; i++)
        pthread_cond_signal(&p->t[i].pending_c);

    pthread_mutex_unlock(&p->pool_m);

    DBG_OUT(stderr, "Shutdown complete\n");

    for (i = 0; i < p->tsize; i++)
        pthread_join(p->t[i].tid, NULL);

    pthread_mutex_destroy(&p->pool_m);
    for (i = 0; i < p->tsize; i++)
        pthread_cond_destroy(&p->t[i].pending_c);

    if (p->t_stack)
        free(p->t_stack);

    free(p->t);
    free(p);

    DBG_OUT(stderr, "Destroyed pool %p\n", p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x4e97e
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x4730
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x4e998
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4e9d2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
addq $0x18, %rdi
callq 0x4040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e99f
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x4330
jmp 0x4e9e1
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4ea1f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4400
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e9e8
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x4570
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4ea66
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
addq $0x18, %rdi
callq 0x49a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4ea33
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4ea7e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rdi
callq 0x45a0
jmp 0x4ea96
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/thread_pool.c
// Function: hts_tpool_kill
void hts_tpool_kill(hts_tpool *p) {
    int i;

    DBG_OUT(stderr, "Destroying pool %p, kill=%d\n", p, kill);

    for (i = 0; i < p->tsize; i++)
        pthread_kill(p->t[i].tid, SIGINT);

    pthread_mutex_destroy(&p->pool_m);
    for (i = 0; i < p->tsize; i++)
        pthread_cond_destroy(&p->t[i].pending_c);

    if (p->t_stack)
        free(p->t_stack);

    free(p->t);
    free(p);

    DBG_OUT(stderr, "Destroyed pool %p\n", p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x4eaae
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4eaed
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movl $0x2, %esi
callq 0x4630
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4eab5
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x4570
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4eb34
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
addq $0x18, %rdi
callq 0x49a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4eb01
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4eb4c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rdi
callq 0x45a0
jmp 0x4eb64
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_io.h
// Function: block_append
static inline int block_append(cram_block *b, const void *s, size_t len) {
    if (block_grow(b, len) < 0)
        return -1;

    if (len) {
        memcpy(BLOCK_END(b), s, len);
        BLOCK_SIZE(b) += len;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x59830
cmpl $0x0, %eax
jge 0x4f01f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4f05a
cmpq $0x0, -0x20(%rbp)
je 0x4f053
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x43b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
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/cram/cram_io.h
// Function: block_append_char
static inline int block_append_char(cram_block *b, char c) {
    if (block_grow(b, 1) < 0)
        return -1;

    b->data[b->byte++] = c;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x59830
cmpl $0x0, %eax
jge 0x4f09e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4f0c6
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rsi
movq 0x30(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x30(%rsi)
movb %dl, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop