LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/annot-tsv.c
// Function: cols_clear
void cols_clear(cols_t *cols)
{
    if ( !cols ) return;
    free(cols->rmme);
    free(cols->off);
    cols->rmme = NULL;
    cols->off  = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6005
jmp 0x6037
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/kstring.h
// Function: kputc
static inline int kputc(int c, kstring_t *s)
{
	if (ks_resize(s, s->l + 2) < 0)
		return EOF;
	s->s[s->l++] = c;
	s->s[s->l] = 0;
	return (unsigned char)c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x2, %rsi
callq 0x9040
cmpl $0x0, %eax
jge 0x6921
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x695e
movl -0x8(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl -0x8(%rbp), %eax
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/kstring.h
// Function: kputw
static inline int kputw(int c, kstring_t *s)
{
    unsigned int x = c;
    if (c < 0) {
        x = -x;
        if (ks_resize(s, s->l + 3) < 0)
            return EOF;
        s->s[s->l++] = '-';
    }

    return kputuw(x, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x69d2
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x3, %rsi
callq 0x9040
cmpl $0x0, %eax
jge 0x69b5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x69e1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb $0x2d, (%rax,%rcx)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x9810
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/khash_str2int.h
// Function: khash_str2int_set
static inline int khash_str2int_set(void *_hash, const char *str, int value)
{
    khint_t k;
    int ret;
    khash_t(str2int) *hash = (khash_t(str2int)*)_hash;
    if ( !hash ) return -1;
    k = kh_put(str2int, hash, str, &ret);
    if (ret < 0) return -1;
    kh_val(hash,k) = value;
    return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6a8b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6ac5
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x99d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x6aae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6ac5
movl -0x1c(%rbp), %edx
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x20(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/annot-tsv.c
// Function: write_header
void write_header(args_t *args, dat_t *dat)
{
    if ( dat->hdr.dummy ) return;
    if ( args->no_write_hdr>1 ) return;
    int i;
    kstring_t str = {0,0,0};
    kputc('#', &str);
    for (i=0; i<dat->hdr.cols->n; i++)
    {
        if ( i>0 ) kputc(dat->delim, &str);
        if ( !args->no_write_hdr ) ksprintf(&str,"[%d]", i+1);
        kputs(dat->hdr.cols->off[i], &str);
    }
    if ( dat->hdr.annots )
    {
        for (i=0; i<dat->hdr.annots->n; i++)
        {
            if ( str.l > 1 ) kputc(dat->delim, &str);
            kputs(dat->hdr.annots->off[i], &str);
        }
    }
    kputc('\n',&str);
    if ( bgzf_write(args->out_fp, str.s, str.l) != str.l ) error("Failed to write %zd bytes\n", str.l);
    free(str.s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x6aef
jmp 0x6c43
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1a4(%rax)
jle 0x6b01
jmp 0x6c43
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4250
movl $0x23, %edi
leaq -0x30(%rbp), %rsi
callq 0x68f0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jae 0x6b99
cmpl $0x0, -0x14(%rbp)
jle 0x6b4c
movq -0x10(%rbp), %rax
movsbl 0x78(%rax), %edi
leaq -0x30(%rbp), %rsi
callq 0x68f0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1a4(%rax)
jne 0x6b71
movl -0x14(%rbp), %edx
addl $0x1, %edx
leaq -0x30(%rbp), %rdi
leaq 0xe6a41(%rip), %rsi     # 0xed5ab
movb $0x0, %al
callq 0xb040
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6c50
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b26
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6bfc
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpl (%rcx), %eax
jae 0x6bfa
cmpq $0x1, -0x30(%rbp)
jbe 0x6bd2
movq -0x10(%rbp), %rax
movsbl 0x78(%rax), %edi
leaq -0x30(%rbp), %rsi
callq 0x68f0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6c50
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6bab
jmp 0x6bfc
movl $0xa, %edi
leaq -0x30(%rbp), %rsi
callq 0x68f0
movq -0x8(%rbp), %rax
movq 0x190(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xffb0
cmpq -0x30(%rbp), %rax
je 0x6c3a
movq -0x30(%rbp), %rsi
leaq 0xe697d(%rip), %rdi     # 0xed5b0
movb $0x0, %al
callq 0x5c70
movq -0x20(%rbp), %rdi
callq 0x45a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/annot-tsv.c
// Function: sanity_check_columns
void sanity_check_columns(char *fname, hdr_t *hdr, cols_t *cols, int **col2idx, int force)
{
    *col2idx = (int*)malloc(sizeof(int)*cols->n);
    if ( !*col2idx ) error("Out of memory, failed to allocate %zu bytes\n",sizeof(int)*cols->n);
    int i, idx;
    for (i=0; i<cols->n; i++)
    {
        if ( khash_str2int_get(hdr->name2idx, cols->off[i], &idx) < 0 )
        {
            if ( !force ) error("The key \"%s\" not found in %s\n", cols->off[i],fname);
            idx = -1;
        }
        (*col2idx)[i] = idx;
    }
}

// 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 -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x4650
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6d7b
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
shlq $0x2, %rsi
leaq 0xe6665(%rip), %rdi     # 0xed3d9
movb $0x0, %al
callq 0x5c70
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x6dfd
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x6e10
cmpl $0x0, %eax
jge 0x6de1
cmpl $0x0, -0x24(%rbp)
jne 0x6dda
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rdx
leaq 0xe67f8(%rip), %rdi     # 0xed5cb
movb $0x0, %al
callq 0x5c70
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6d82
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/khash_str2int.h
// Function: khash_str2int_get
static inline int khash_str2int_get(void *_hash, const char *str, int *value)
{
    khash_t(str2int) *hash = (khash_t(str2int)*)_hash;
    khint_t k;
    if ( !hash ) return -1;
    k = kh_get(str2int, hash, str);
    if ( k == kh_end(hash) ) return -1;
    if ( !value ) return 0;
    *value = kh_val(hash, k);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6e3c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6e8b
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa380
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x6e60
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6e8b
cmpq $0x0, -0x20(%rbp)
jne 0x6e70
movl $0x0, -0x4(%rbp)
jmp 0x6e8b
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/annot-tsv.c
// Function: parse_coor_base
void parse_coor_base(args_t *args, char *str, dat_t *dat)
{
    int len = strlen(dat->fname);
    int beg = 1, end = 1;
    if ( *str )
    {
        if ( str[0]=='0' ) beg = 0;
        else if ( str[0]=='1' ) beg = 1;
        else error("Could not parse: --coords %s\n",args->coords_str);

        if ( str[1]=='0' ) end = 0;
        else if ( str[1]=='1' ) end = 1;
        else error("Could not parse: --coords %s\n",args->coords_str);
    }
    else if ( len>=4 && !strcasecmp(".bed",dat->fname+len-4) ) beg = 0;
    else if ( len>=7 && !strcasecmp(".bed.gz",dat->fname+len-7) ) beg = 0;
    dat->coor_base[0] = beg;
    dat->coor_base[1] = end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x41b0
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6f6c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x6ef3
movl $0x0, -0x20(%rbp)
jmp 0x6f23
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x6f08
movl $0x1, -0x20(%rbp)
jmp 0x6f21
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rsi
leaq 0xe66cf(%rip), %rdi     # 0xed5e9
movb $0x0, %al
callq 0x5c70
jmp 0x6f23
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x30, %eax
jne 0x6f39
movl $0x0, -0x24(%rbp)
jmp 0x6f6a
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x31, %eax
jne 0x6f4f
movl $0x1, -0x24(%rbp)
jmp 0x6f68
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rsi
leaq 0xe6688(%rip), %rdi     # 0xed5e9
movb $0x0, %al
callq 0x5c70
jmp 0x6f6a
jmp 0x6fd2
cmpl $0x4, -0x1c(%rbp)
jl 0x6f9e
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
addq $-0x4, %rsi
leaq 0xe667c(%rip), %rdi     # 0xed607
callq 0x4500
cmpl $0x0, %eax
jne 0x6f9e
movl $0x0, -0x20(%rbp)
jmp 0x6fd0
cmpl $0x7, -0x1c(%rbp)
jl 0x6fce
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
addq $-0x7, %rsi
leaq 0xe664f(%rip), %rdi     # 0xed60c
callq 0x4500
cmpl $0x0, %eax
jne 0x6fce
movl $0x0, -0x20(%rbp)
jmp 0x6fd0
jmp 0x6fd2
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x70(%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x74(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/annot-tsv.c
// Function: read_next_line
static int read_next_line(dat_t *dat)
{
    if ( dat->line.l ) return dat->line.l;
    int ret = hts_getline(dat->fp, KS_SEP_LINE, &dat->line);
    if ( ret > 0 ) return dat->line.l;
    if ( ret < -1 ) error("Error encountered while reading %s\n",dat->fname);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x7f2a
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x7f85
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x80, %rdx
movl $0x2, %esi
callq 0x1dfd0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x7f63
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x7f85
cmpl $-0x1, -0x14(%rbp)
jge 0x7f7e
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xe5a7b(%rip), %rdi     # 0xed9f2
movb $0x0, %al
callq 0x5c70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/annot-tsv.c
// Function: write_annots
static void write_annots(args_t *args)
{
    if ( !args->dst.annots ) return;

    args->tmp_kstr.l = 0;
    int i;
    hts_pos_t len = nbp_length(args->nbp);
    for (i=0; i<args->dst.annots->n; i++)
    {
        if ( args->dst.annots_idx[i]==ANN_NBP )
        {
            kputc(args->dst.delim,&args->tmp_kstr);
            kputw(len,&args->tmp_kstr);
        }
        else if ( args->dst.annots_idx[i]==ANN_FRAC )
        {
            kputc(args->dst.delim,&args->tmp_kstr);
            kputd((double)len/(args->nbp->end - args->nbp->beg + 1),&args->tmp_kstr);
        }
        else if ( args->dst.annots_idx[i]==ANN_CNT )
        {
            kputc(args->dst.delim,&args->tmp_kstr);
            kputw(args->nbp->n/2,&args->tmp_kstr);
        }
    }
    write_string(args, args->tmp_kstr.s, args->tmp_kstr.l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x8d1c
jmp 0x8e84
movq -0x8(%rbp), %rax
movq $0x0, 0x1d0(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa4d0
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
cmpl (%rcx), %eax
jae 0x8e65
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x8d9d
movq -0x8(%rbp), %rax
movsbl 0x80(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x1d0, %rsi            # imm = 0x1D0
callq 0x68f0
movq -0x18(%rbp), %rax
movl %eax, %edi
movq -0x8(%rbp), %rsi
addq $0x1d0, %rsi            # imm = 0x1D0
callq 0x6970
jmp 0x8e55
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x8e05
movq -0x8(%rbp), %rax
movsbl 0x80(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x1d0, %rsi            # imm = 0x1D0
callq 0x68f0
cvtsi2sdq -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq 0x18(%rcx), %rax
addq $0x1, %rax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0xa650
jmp 0x8e53
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x4, (%rax,%rcx,4)
jne 0x8e51
movq -0x8(%rbp), %rax
movsbl 0x80(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x1d0, %rsi            # imm = 0x1D0
callq 0x68f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
shrq %rax
movl %eax, %edi
movq -0x8(%rbp), %rsi
addq $0x1d0, %rsi            # imm = 0x1D0
callq 0x6970
jmp 0x8e53
jmp 0x8e55
jmp 0x8e57
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8d42
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rdx
callq 0x8c80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/annot-tsv.c
// Function: nbp_add
static inline void nbp_add(nbp_t *nbp, hts_pos_t beg, hts_pos_t end)
{
    nbp->n += 2;
    if ( nbp->n >= nbp->m )
    {
        nbp->m += 2;
        nbp->regs = realloc(nbp->regs, nbp->m*sizeof(*nbp->regs));
        if ( !nbp->regs ) error("Out of memory, failed to allocate %zu bytes\n",nbp->m*sizeof(*nbp->regs));
    }
    nbp->regs[nbp->n - 2] = NBP_SET_BEG(beg);
    nbp->regs[nbp->n - 1] = NBP_SET_END(end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x8f9e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x4820
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x8f9c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
leaq 0xe4444(%rip), %rdi     # 0xed3d9
movb $0x0, %al
callq 0x5c70
jmp 0x8f9e
movq -0x10(%rbp), %rdx
shlq %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq $0x2, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
shlq %rdx
addq $0x1, %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/khash_str2int.h
// Function: khash_str2int_has_key
static inline int khash_str2int_has_key(void *_hash, const char *str)
{
    khash_t(str2int) *hash = (khash_t(str2int)*)_hash;
    khint_t k = kh_get(str2int, hash, str);
    if ( k == kh_end(hash) ) return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa380
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x902c
movl $0x0, -0x4(%rbp)
jmp 0x9033
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/kstring.h
// Function: ks_resize
static inline int ks_resize(kstring_t *s, size_t size)
{
	if (s->m < size) {
	    char *tmp;
	    size = (size > (SIZE_MAX>>2)) ? size : size + (size >> 1);
	    tmp = (char*)realloc(s->s, size);
	    if (!tmp)
	        return -1;
	    s->s = tmp;
	    s->m = size;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x90cf
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, -0x18(%rbp)
jbe 0x9078
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x908a
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4820
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x90b7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x90d6
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/khash.h
// Function: _ac_FNV1a_hash_string
static kh_inline khint_t __ac_FNV1a_hash_string(const char *s)
{
	const khint_t offset_basis = 2166136261;
	const khint_t FNV_prime = 16777619;
	khint_t h = offset_basis;
	for (; *s; ++s) h = (h ^ (uint8_t) *s) * FNV_prime;
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x811c9dc5, -0xc(%rbp) # imm = 0x811C9DC5
movl $0x1000193, -0x10(%rbp) # imm = 0x1000193
movl $0x811c9dc5, -0x14(%rbp) # imm = 0x811C9DC5
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa279
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
xorl %ecx, %eax
imull $0x1000193, %eax, %eax  # imm = 0x1000193
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xa24d
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/kstring.h
// Function: kputsn
static inline int kputsn(const char *p, size_t l, kstring_t *s)
{
	size_t new_sz = s->l + l + 2;
	if (new_sz <= s->l) { errno = EOVERFLOW; return EOF; }
	if (ks_resize(s, new_sz) < 0) return EOF;
	memcpy(s->s + s->l, p, l);
	s->l += l;
	s->s[s->l] = 0;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
ja 0xa2c8
callq 0x4050
movl $0x4b, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa327
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9040
cmpl $0x0, %eax
jge 0xa2e3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa327
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
addq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x43b0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/annot-tsv.c
// Function: nbp_length
static hts_pos_t nbp_length(nbp_t *nbp)
{
    qsort(nbp->regs, nbp->n, sizeof(*nbp->regs), compare_hts_pos);
    int i, nopen = 0;
    hts_pos_t beg = 0, length = 0;
    for (i=0; i<nbp->n; i++)
    {
        if ( NBP_IS_BEG(nbp->regs[i]) )
        {
            if ( !nopen ) beg = NBP_GET(nbp->regs[i]);
            nopen++;
        }
        else nopen--;
        assert( nopen>=0 );
        if ( nopen==0 && beg>0 ) length += NBP_GET(nbp->regs[i]) - beg + 1;
    }
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x8, %edx
leaq 0xf9(%rip), %rcx        # 0xa5f0
callq 0x4990
movl $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xa5dd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xa56d
cmpl $0x0, -0x10(%rbp)
jne 0xa562
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
sarq %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa576
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0xa57e
jmp 0xa59d
leaq 0xe3491(%rip), %rdi     # 0xeda16
leaq 0xe2fbb(%rip), %rsi     # 0xed547
movl $0xb5, %edx
leaq 0xe3487(%rip), %rcx     # 0xeda1f
callq 0x42e0
cmpl $0x0, -0x10(%rbp)
jne 0xa5cd
cmpq $0x0, -0x18(%rbp)
jle 0xa5cd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
sarq %rax
subq -0x18(%rbp), %rax
addq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xa5cf
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa51a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/annot-tsv.c
// Function: compare_hts_pos
static int compare_hts_pos(const void *aptr, const void *bptr)
{
    hts_pos_t a = *(const hts_pos_t*) aptr;
    hts_pos_t b = *(const hts_pos_t*) bptr;
    if (a < b) return -1;
    if (a > b) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0xa625
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa63f
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0xa638
movl $0x1, -0x4(%rbp)
jmp 0xa63f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/kstring.c
// Function: kgetline
int kgetline(kstring_t *s, kgets_func *fgets_fn, void *fp)
{
	size_t l0 = s->l;

	while (s->l == l0 || s->s[s->l-1] != '\n') {
		if (s->m - s->l < 200) {
			if (ks_resize(s, s->m + 200) < 0)
				return EOF;
		}
		if (fgets_fn(s->s + s->l, s->m - s->l, fp) == NULL) break;
		s->l += strlen(s->s + s->l);
	}

	if (s->l == l0) return EOF;

	if (s->l > l0 && s->s[s->l-1] == '\n') {
		s->l--;
		if (s->l > l0 && s->s[s->l-1] == '\r') s->l--;
	}
	s->s[s->l] = '\0';
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpq -0x28(%rbp), %rcx
movb %al, -0x29(%rbp)
je 0xb651
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xb65d
jmp 0xb6f7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
cmpq $0xc8, %rax
jae 0xb69f
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0xc8, %rsi
callq 0xad90
cmpl $0x0, %eax
jge 0xb69d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb79a
jmp 0xb69f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x10(%rbp), %rcx
addq (%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq (%rdx), %rcx
movl %ecx, %esi
movq -0x20(%rbp), %rdx
callq *%rax
cmpq $0x0, %rax
jne 0xb6d1
jmp 0xb6f7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
addq (%rax), %rdi
callq 0x41b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0xb61f
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0xb710
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb79a
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jbe 0xb780
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xb780
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jbe 0xb77e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0xb77e
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0xb780
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/kstring.c
// Function: kmemmem
void *kmemmem(const void *_str, int n, const void *_pat, int m, int **_prep)
{
	int i, j, *prep = 0, *bmGs, *bmBc;
	const ubyte_t *str, *pat;
	str = (const ubyte_t*)_str; pat = (const ubyte_t*)_pat;
	prep = (_prep == 0 || *_prep == 0)? ksBM_prep(pat, m) : *_prep;
    if (!prep) return NULL;
	if (_prep && *_prep == 0) *_prep = prep;
	bmGs = prep; bmBc = prep + m;
	j = 0;
	while (j <= n - m) {
		for (i = m - 1; i >= 0 && pat[i] == str[i+j]; --i);
		if (i >= 0) {
			int max = bmBc[str[i+j]] - m + 1 + i;
			if (max < bmGs[i]) max = bmGs[i];
			j += max;
		} else return (void*)(str + j);
	}
	if (_prep == 0) free(prep);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xb9a6
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb9b8
movq -0x60(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0xbb10
movq %rax, -0x70(%rbp)
jmp 0xb9c3
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xb9df
movq $0x0, -0x8(%rbp)
jmp 0xbafe
cmpq $0x0, -0x30(%rbp)
je 0xb9fb
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb9fb
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x14(%rbp), %ecx
subl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jg 0xbae6
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x34(%rbp)
movb %al, -0x71(%rbp)
jl 0xba67
movq -0x60(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x58(%rbp), %rcx
movl -0x34(%rbp), %edx
addl -0x38(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xba70
jmp 0xba7d
jmp 0xba72
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xba37
cmpl $0x0, -0x34(%rbp)
jl 0xbad0
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movl -0x34(%rbp), %edx
addl -0x38(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
movl (%rax,%rcx,4), %eax
subl -0x24(%rbp), %eax
addl $0x1, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x48(%rbp), %rcx
movslq -0x34(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xbac5
movq -0x48(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0xbae1
movq -0x58(%rbp), %rax
movslq -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xbafe
jmp 0xba1d
cmpq $0x0, -0x30(%rbp)
jne 0xbaf6
movq -0x40(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzf.c
// Function: bgzf_open
BGZF *bgzf_open(const char *path, const char *mode)
{
    BGZF *fp = 0;
    if (strchr(mode, 'r')) {
        hFILE *fpr;
        if ((fpr = hopen(path, mode)) == 0) return 0;
        fp = bgzf_read_init(fpr, path);
        if (fp == 0) { hclose_abruptly(fpr); return NULL; }
        fp->fp = fpr;
    } else if (strchr(mode, 'w') || strchr(mode, 'a')) {
        hFILE *fpw;
        if ((fpw = hopen(path, mode)) == 0) return 0;
        fp = bgzf_write_init(mode);
        if (fp == NULL) return NULL;
        fp->fp = fpw;
    }
    else { errno = EINVAL; return 0; }

    fp->is_be = ed_is_big();
    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x72, %esi
callq 0x4170
cmpq $0x0, %rax
je 0xc121
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq 0x158b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xc0e2
movq $0x0, -0x8(%rbp)
jmp 0xc1d4
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc1e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc110
movq -0x28(%rbp), %rdi
callq 0x149d0
movq $0x0, -0x8(%rbp)
jmp 0xc1d4
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0xc1af
movq -0x18(%rbp), %rdi
movl $0x77, %esi
callq 0x4170
cmpq $0x0, %rax
jne 0xc149
movq -0x18(%rbp), %rdi
movl $0x61, %esi
callq 0x4170
cmpq $0x0, %rax
je 0xc198
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq 0x158b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc16c
movq $0x0, -0x8(%rbp)
jmp 0xc1d4
movq -0x18(%rbp), %rdi
callq 0xc480
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc18a
movq $0x0, -0x8(%rbp)
jmp 0xc1d4
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0xc1ad
callq 0x4050
movl $0x16, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xc1d4
jmp 0xc1af
callq 0xc710
movl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0x1, %edx
shll $0x13, %edx
andl $0xfff7ffff, %ecx       # imm = 0xFFF7FFFF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzf.c
// Function: bgzf_dopen
BGZF *bgzf_dopen(int fd, const char *mode)
{
    BGZF *fp = 0;
    if (strchr(mode, 'r')) {
        hFILE *fpr;
        if ((fpr = hdopen(fd, mode)) == 0) return 0;
        fp = bgzf_read_init(fpr, NULL);
        if (fp == 0) { hclose_abruptly(fpr); return NULL; } // FIXME this closes fd
        fp->fp = fpr;
    } else if (strchr(mode, 'w') || strchr(mode, 'a')) {
        hFILE *fpw;
        if ((fpw = hdopen(fd, mode)) == 0) return 0;
        fp = bgzf_write_init(mode);
        if (fp == NULL) return NULL;
        fp->fp = fpw;
    }
    else { errno = EINVAL; return 0; }

    fp->is_be = ed_is_big();
    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x72, %esi
callq 0x4170
cmpq $0x0, %rax
je 0xc7bd
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x14a40
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xc77e
movq $0x0, -0x8(%rbp)
jmp 0xc86d
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc1e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc7ac
movq -0x28(%rbp), %rdi
callq 0x149d0
movq $0x0, -0x8(%rbp)
jmp 0xc86d
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0xc848
movq -0x18(%rbp), %rdi
movl $0x77, %esi
callq 0x4170
cmpq $0x0, %rax
jne 0xc7e5
movq -0x18(%rbp), %rdi
movl $0x61, %esi
callq 0x4170
cmpq $0x0, %rax
je 0xc831
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x14a40
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc805
movq $0x0, -0x8(%rbp)
jmp 0xc86d
movq -0x18(%rbp), %rdi
callq 0xc480
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc823
movq $0x0, -0x8(%rbp)
jmp 0xc86d
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0xc846
callq 0x4050
movl $0x16, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xc86d
jmp 0xc848
callq 0xc710
movl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0x1, %edx
shll $0x13, %edx
andl $0xfff7ffff, %ecx       # imm = 0xFFF7FFFF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzf.c
// Function: bgzf_hopen
BGZF *bgzf_hopen(hFILE *hfp, const char *mode)
{
    BGZF *fp = NULL;
    if (strchr(mode, 'r')) {
        fp = bgzf_read_init(hfp, NULL);
        if (fp == NULL) return NULL;
    } else if (strchr(mode, 'w') || strchr(mode, 'a')) {
        fp = bgzf_write_init(mode);
        if (fp == NULL) return NULL;
    }
    else { errno = EINVAL; return 0; }

    fp->fp = hfp;
    fp->is_be = ed_is_big();
    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x72, %esi
callq 0x4170
cmpq $0x0, %rax
je 0xc8d3
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc1e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc8d1
movq $0x0, -0x8(%rbp)
jmp 0xc963
jmp 0xc932
movq -0x18(%rbp), %rdi
movl $0x77, %esi
callq 0x4170
cmpq $0x0, %rax
jne 0xc8fb
movq -0x18(%rbp), %rdi
movl $0x61, %esi
callq 0x4170
cmpq $0x0, %rax
je 0xc91b
movq -0x18(%rbp), %rdi
callq 0xc480
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc919
movq $0x0, -0x8(%rbp)
jmp 0xc963
jmp 0xc930
callq 0x4050
movl $0x16, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xc963
jmp 0xc932
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
callq 0xc710
movl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0x1, %edx
shll $0x13, %edx
andl $0xfff7ffff, %ecx       # imm = 0xFFF7FFFF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzf.c
// Function: bgzf_zerr
static const char *bgzf_zerr(int errnum, z_stream *zs)
{
    static char buffer[32];

    /* Return zs->msg if available.
       zlib doesn't set this very reliably.  Looking at the source suggests
       that it may get set to a useful message for deflateInit2, inflateInit2
       and inflate when it returns Z_DATA_ERROR. For inflate with other
       return codes, deflate, deflateEnd and inflateEnd it doesn't appear
       to be useful.  For the likely non-useful cases, the caller should
       pass NULL into zs. */

    if (zs && zs->msg) return zs->msg;

    // gzerror OF((gzFile file, int *errnum)
    switch (errnum) {
    case Z_ERRNO:
        return strerror(errno);
    case Z_STREAM_ERROR:
        return "invalid parameter/compression level, or inconsistent stream state";
    case Z_DATA_ERROR:
        return "invalid or incomplete IO";
    case Z_MEM_ERROR:
        return "out of memory";
    case Z_BUF_ERROR:
        return "progress temporarily not possible, or in() / out() returned an error";
    case Z_VERSION_ERROR:
        return "zlib version mismatch";
    case Z_NEED_DICT:
        return "data was compressed using a dictionary";
    case Z_OK: // 0: maybe gzgets error Z_NULL
    default:
        snprintf(buffer, sizeof(buffer), "[%d] unknown", errnum);
        return buffer;  // FIXME: Not thread-safe.
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcd72
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xcd72
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xce21
movl -0xc(%rbp), %eax
addl $0x6, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x8, %eax
ja 0xcdf9
movq -0x20(%rbp), %rax
leaq 0xe1d72(%rip), %rcx     # 0xeeb00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x4050
movl (%rax), %edi
callq 0x4130
movq %rax, -0x8(%rbp)
jmp 0xce21
leaq 0xe256e(%rip), %rax     # 0xef31e
movq %rax, -0x8(%rbp)
jmp 0xce21
leaq 0xe25a3(%rip), %rax     # 0xef360
movq %rax, -0x8(%rbp)
jmp 0xce21
leaq 0xe25af(%rip), %rax     # 0xef379
movq %rax, -0x8(%rbp)
jmp 0xce21
leaq 0xe25b0(%rip), %rax     # 0xef387
movq %rax, -0x8(%rbp)
jmp 0xce21
leaq 0xe25e8(%rip), %rax     # 0xef3cc
movq %rax, -0x8(%rbp)
jmp 0xce21
leaq 0xe25f1(%rip), %rax     # 0xef3e2
movq %rax, -0x8(%rbp)
jmp 0xce21
jmp 0xcdf9
movl -0xc(%rbp), %ecx
leaq 0x10514d(%rip), %rdi    # 0x111f50
movl $0x20, %esi
leaq 0xe25fa(%rip), %rdx     # 0xef409
movb $0x0, %al
callq 0x47e0
leaq 0x105133(%rip), %rax    # 0x111f50
movq %rax, -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/bgzf.c
// Function: bgzf_htell
static off_t bgzf_htell(BGZF *fp) {
    if (fp->mt) {
        pthread_mutex_lock(&fp->mt->job_pool_m);
        off_t pos = fp->block_address + fp->block_clength;
        pthread_mutex_unlock(&fp->mt->job_pool_m);
        return pos;
    } else {
        return htell(fp->fp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xddda
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x30, %rdi
callq 0x4730
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x30, %rdi
callq 0x4330
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xddeb
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0xebf0
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/./htslib/hfile.h
// Function: hread
static inline ssize_t HTS_RESULT_USED
hread(hFILE *fp, void *buffer, size_t nbytes)
{
    HTSLIB_EXPORT
    extern ssize_t hread2(hFILE *, void *, size_t, size_t);

    size_t n = fp->end - fp->begin;
    if (n > nbytes) n = nbytes;
    memcpy(buffer, fp->begin, n);
    fp->begin += n;
    return (n == nbytes || !fp->mobile)? (ssize_t) n : hread2(fp, buffer, nbytes, n);
}

// 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 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0xde3d
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x43b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xde7f
movq -0x8(%rbp), %rax
movb 0x30(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xde89
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xdea2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x14160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzf.c
// Function: load_block_from_cache
static int load_block_from_cache(BGZF *fp, int64_t block_address)
{
    khint_t k;
    cache_t *p;

    khash_t(cache) *h = fp->cache->h;
    k = kh_get(cache, h, block_address);
    if (k == kh_end(h)) return 0;
    p = &kh_val(h, k);
    if (fp->block_length != 0) fp->block_offset = 0;
    fp->block_address = block_address;
    fp->block_length = p->size;
    memcpy(fp->uncompressed_block, p->block, p->size);
    if ( hseek(fp->fp, p->end_offset, SEEK_SET) < 0 )
    {
        // todo: move the error up
        hts_log_error("Could not hseek to %" PRId64, p->end_offset);
        exit(1);
    }
    return p->size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x120b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xe1a6
movl $0x0, -0x4(%rbp)
jmp 0xe258
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xe1d1
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movslq (%rax), %rdx
callq 0x43b0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
callq 0x146a0
cmpq $0x0, %rax
jge 0xe24f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %edi
leaq 0xe1243(%rip), %rsi     # 0xef47a
leaq 0xe1252(%rip), %rdx     # 0xef490
movb $0x0, %al
callq 0x1b030
movl $0x1, %edi
callq 0x45c0
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzf.c
// Function: check_header
static int check_header(const uint8_t *header)
{
    if ( header[0] != 31 || header[1] != 139 || header[2] != 8 ) return -2;
    return ((header[3] & 4) != 0
            && unpackInt16((uint8_t*)&header[10]) == 6
            && header[12] == 'B' && header[13] == 'C'
            && unpackInt16((uint8_t*)&header[14]) == 2) ? 0 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1f, %eax
jne 0xe2a4
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x8b, %eax
jne 0xe2a4
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x8, %eax
je 0xe2ad
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xe328
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %ecx
andl $0x4, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0xe315
movq -0x10(%rbp), %rdi
addq $0xa, %rdi
callq 0xe340
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x6, %ecx
movb %al, -0x11(%rbp)
jne 0xe315
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %ecx
xorl %eax, %eax
cmpl $0x42, %ecx
movb %al, -0x11(%rbp)
jne 0xe315
movq -0x10(%rbp), %rax
movzbl 0xd(%rax), %ecx
xorl %eax, %eax
cmpl $0x43, %ecx
movb %al, -0x11(%rbp)
jne 0xe315
movq -0x10(%rbp), %rdi
addq $0xe, %rdi
callq 0xe340
cmpl $0x2, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -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/bgzf.c
// Function: inflate_block
static int inflate_block(BGZF* fp, int block_length)
{
    size_t dlen = BGZF_MAX_BLOCK_SIZE;
    uint32_t crc = le_to_u32((uint8_t *)fp->compressed_block + block_length-8);
    int ret = bgzf_uncompress(fp->uncompressed_block, &dlen,
                              (Bytef*)fp->compressed_block + 18,
                              block_length - 18, crc);
    if (ret < 0) {
        if (ret == -2)
            fp->errcode |= BGZF_ERR_CRC;
        else
            fp->errcode |= BGZF_ERR_ZLIB;
        return -1;
    }

    return dlen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x10000, -0x20(%rbp)   # imm = 0x10000
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
addq $-0x8, %rdi
callq 0x12200
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
addq $0x12, %rdx
movl -0x14(%rbp), %eax
subl $0x12, %eax
movslq %eax, %rcx
movl -0x24(%rbp), %r8d
leaq -0x20(%rbp), %rsi
callq 0x12210
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0xe418
cmpl $-0x2, -0x28(%rbp)
jne 0xe3ee
movq -0x10(%rbp), %rax
movl (%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
orl $0x20, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
jmp 0xe40f
movq -0x10(%rbp), %rax
movl (%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
orl $0x1, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe41f
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)