LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_idx_get_stat
int hts_idx_get_stat(const hts_idx_t* idx, int tid, uint64_t* mapped, uint64_t* unmapped)
{
    if (!idx) return -1;
    if ( idx->fmt == HTS_FMT_CRAI ) {
        *mapped = 0; *unmapped = 0;
        return -1;
    }

    bidx_t *h = idx->bidx[tid];
    if (!h) return -1;
    khint_t k = kh_get(bin, h, META_BIN(idx));
    if (k != kh_end(h)) {
        *mapped = kh_val(h, k).list[1].u;
        *unmapped = kh_val(h, k).list[1].v;
        return 0;
    } else {
        *mapped = 0; *unmapped = 0;
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x209ca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20aa5
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x209f5
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20aa5
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x20a1c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20aa5
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
addl $0x1, %esi
callq 0x20ab0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x20a88
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x20aa5
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_itr_destroy
void hts_itr_destroy(hts_itr_t *iter)
{
    if (iter) {
        if (iter->multi) {
            hts_reglist_free(iter->reg_list, iter->n_reg);
        } else {
            free(iter->bins.a);
        }

        if (iter->off)
            free(iter->off);
        free(iter);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x21b3b
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x21b0a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x312c0
jmp 0x21b1a
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x21b32
movq -0x8(%rbp), %rax
movq 0x60(%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/hts.c
// Function: hts_memrchr
static void *hts_memrchr(const void *s, int c, size_t n) {
    size_t i;
    unsigned char *u = (unsigned char *)s;
    for (i = n; i > 0; i--) {
        if (u[i-1] == c)
            return u+i-1;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x23c3d
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
cmpl -0x14(%rbp), %eax
jne 0x23c2d
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x23c45
jmp 0x23c2f
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x23bff
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_parse_reg64
const char *hts_parse_reg64(const char *s, hts_pos_t *beg, hts_pos_t *end)
{
    char *hyphen;
    const char *colon = strrchr(s, ':');
    if (colon == NULL) {
        *beg = 0; *end = HTS_POS_MAX;
        return s + strlen(s);
    }

    *beg = hts_parse_decimal(colon+1, &hyphen, HTS_PARSE_THOUSANDS_SEP) - 1;
    if (*beg < 0) *beg = 0;

    if (*hyphen == '\0') *end = HTS_POS_MAX;
    else if (*hyphen == '-') *end = hts_parse_decimal(hyphen+1, NULL, HTS_PARSE_THOUSANDS_SEP);
    else return NULL;

    if (*beg >= *end) return NULL;
    return colon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x4510
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x23d6d
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movabsq $0x7fffffff7fffffff, %rcx # imm = 0x7FFFFFFF7FFFFFFF
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x23e21
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x23070
movq %rax, %rcx
subq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jge 0x23da6
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x23dc5
movq -0x20(%rbp), %rax
movabsq $0x7fffffff7fffffff, %rcx # imm = 0x7FFFFFFF7FFFFFFF
movq %rcx, (%rax)
jmp 0x23dff
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x23df3
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x23070
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x23dfd
movq $0x0, -0x8(%rbp)
jmp 0x23e21
jmp 0x23dff
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jl 0x23e19
movq $0x0, -0x8(%rbp)
jmp 0x23e21
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_parse_reg
const char *hts_parse_reg(const char *s, int *beg, int *end)
{
    hts_pos_t beg64 = 0, end64 = 0;
    const char *colon = hts_parse_reg64(s, &beg64, &end64);
    if (beg64 > INT_MAX) {
        hts_log_error("Position %"PRId64" too large", beg64);
        return NULL;
    }
    if (end64 > INT_MAX) {
        if (end64 == HTS_POS_MAX) {
            end64 = INT_MAX;
        } else {
            hts_log_error("Position %"PRId64" too large", end64);
            return NULL;
        }
    }
    *beg = beg64;
    *end = end64;
    return colon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x23d00
movq %rax, -0x38(%rbp)
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
jle 0x23e9b
movq -0x28(%rbp), %rcx
movl $0x1, %edi
leaq 0xccb47(%rip), %rsi     # 0xf09ca
leaq 0xccb4e(%rip), %rdx     # 0xf09d8
movb $0x0, %al
callq 0x1b030
movq $0x0, -0x8(%rbp)
jmp 0x23f09
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jle 0x23ee9
movabsq $0x7fffffff7fffffff, %rax # imm = 0x7FFFFFFF7FFFFFFF
cmpq %rax, -0x30(%rbp)
jne 0x23ebf
movq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jmp 0x23ee7
movq -0x30(%rbp), %rcx
movl $0x1, %edi
leaq 0xccafb(%rip), %rsi     # 0xf09ca
leaq 0xccb02(%rip), %rdx     # 0xf09d8
movb $0x0, %al
callq 0x1b030
movq $0x0, -0x8(%rbp)
jmp 0x23f09
jmp 0x23ee9
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_itr_querys
hts_itr_t *hts_itr_querys(const hts_idx_t *idx, const char *reg, hts_name2id_f getid, void *hdr, hts_itr_query_func *itr_query, hts_readrec_func *readrec)
{
    int tid;
    hts_pos_t beg, end;

    if (strcmp(reg, ".") == 0)
        return itr_query(idx, HTS_IDX_START, 0, 0, readrec);
    else if (strcmp(reg, "*") == 0)
        return itr_query(idx, HTS_IDX_NOCOOR, 0, 0, readrec);

    if (!hts_parse_region(reg, &tid, &beg, &end, getid, hdr, HTS_PARSE_THOUSANDS_SEP))
        return NULL;

    return itr_query(idx, tid, beg, end, readrec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xcb31b(%rip), %rsi     # 0xef266
callq 0x4690
cmpl $0x0, %eax
jne 0x23f76
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %r8
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %ecx, %ecx
movq %rcx, %rdx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x23ffc
movq -0x18(%rbp), %rdi
leaq 0xced42(%rip), %rsi     # 0xf2cc3
callq 0x4690
cmpl $0x0, %eax
jne 0x23fa9
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %r8
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
xorl %ecx, %ecx
movq %rcx, %rdx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x23ffc
jmp 0x23fab
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x3c(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movl $0x1, (%rsp)
callq 0x234d0
cmpq $0x0, %rax
jne 0x23fdf
movq $0x0, -0x8(%rbp)
jmp 0x23ffc
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %r8
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: compare_regions
static int compare_regions(const void *r1, const void *r2) {
    hts_reglist_t *reg1 = (hts_reglist_t *)r1;
    hts_reglist_t *reg2 = (hts_reglist_t *)r2;

    if (reg1->tid < 0 && reg2->tid >= 0)
        return 1;
    else if (reg1->tid >= 0 && reg2->tid < 0)
        return -1;
    else
        return reg1->tid - reg2->tid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jge 0x24319
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x24319
movl $0x1, -0x4(%rbp)
jmp 0x24347
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x24336
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jge 0x24336
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x24347
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x28(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: idx_filename
static char *idx_filename(const char *fn, const char *ext, int download) {
    int ret, local_len;
    char *fnidx;
    const char *local_fn = NULL;
    kstring_t buffer = KS_INITIALIZE;

    // First try : append `ext` to `fn`
    if (!(fnidx = haddextension(&buffer, fn, 0, ext))) {
        free(buffer.s);
        return NULL;
    }
    if ((ret = idx_test_and_fetch(fnidx, &local_fn, &local_len, download)) == -1) {
        // Second try : replace suffix of `fn` with `ext`
        if (!(fnidx = haddextension(&buffer, fn, 1, ext))) {
            free(buffer.s);
            return NULL;
        }
        ret = idx_test_and_fetch(fnidx, &local_fn, &local_len, download);
    }

    if (ret < 0) {
        free(buffer.s);
        return NULL;
    }

    memmove(fnidx, local_fn, local_len);
    fnidx[local_len] = 0;
    return fnidx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4250
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x50(%rbp), %rdi
xorl %edx, %edx
callq 0x15d40
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x259ce
movq -0x40(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
jmp 0x25a72
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %ecx
leaq -0x38(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x25f90
movl %eax, -0x20(%rbp)
cmpl $-0x1, %eax
jne 0x25a34
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x50(%rbp), %rdi
movl $0x1, %edx
callq 0x15d40
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x25a1d
movq -0x40(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
jmp 0x25a72
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %ecx
leaq -0x38(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x25f90
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x25a4d
movq -0x40(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
jmp 0x25a72
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x4810
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: get_severity_tag
static char get_severity_tag(enum htsLogLevel severity)
{
    switch (severity) {
    case HTS_LOG_ERROR:
        return 'E';
    case HTS_LOG_WARNING:
        return 'W';
    case HTS_LOG_INFO:
        return 'I';
    case HTS_LOG_DEBUG:
        return 'D';
    case HTS_LOG_TRACE:
        return 'T';
    default:
        break;
    }

    return '*';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x5, %eax
ja 0x26cd9
movq -0x10(%rbp), %rax
leaq 0xc8e5e(%rip), %rcx     # 0xefb10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x45, -0x1(%rbp)
jmp 0x26cdf
movb $0x57, -0x1(%rbp)
jmp 0x26cdf
movb $0x49, -0x1(%rbp)
jmp 0x26cdf
movb $0x44, -0x1(%rbp)
jmp 0x26cdf
movb $0x54, -0x1(%rbp)
jmp 0x26cdf
jmp 0x26cdb
movb $0x2a, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: reg2bins_narrow
static inline int reg2bins_narrow(int64_t beg, int64_t end, hts_itr_t *itr, int min_shift, int n_lvls, bidx_t *bidx)
{
    int l, t, s = min_shift + (n_lvls<<1) + n_lvls;
    for (--end, l = 0, t = 0; l <= n_lvls; s -= 3, t += 1<<((l<<1)+l), ++l) {
        hts_pos_t b, e;
        int i;
        b = t + (beg>>s); e = t + (end>>s);
        for (i = b; i <= e; ++i) {
            if (kh_get(bin, bidx, i) != kh_end(bidx)) {
                assert(itr->bins.n < itr->bins.m);
                itr->bins.a[itr->bins.n++] = i;
            }
        }
    }
    return itr->bins.n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x2879c
movslq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdx
movl -0x34(%rbp), %ecx
sarq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movslq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdx
movl -0x34(%rbp), %ecx
sarq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movl %eax, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
cmpq -0x48(%rbp), %rax
jg 0x2876e
movq -0x28(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x20ab0
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
je 0x2875e
movq -0x18(%rbp), %rax
movl 0x80(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x84(%rcx), %eax
jge 0x28716
jmp 0x28735
leaq 0xc8553(%rip), %rdi     # 0xf0c70
leaq 0xc7eb4(%rip), %rsi     # 0xf05d8
movl $0xc22, %edx            # imm = 0xC22
leaq 0xc855a(%rip), %rcx     # 0xf0c8a
callq 0x42e0
movl -0x4c(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x18(%rbp), %rsi
movl 0x80(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x80(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x28760
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x286dc
jmp 0x28770
movl -0x34(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %ecx
shll %ecx
addl -0x2c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x28699
movq -0x18(%rbp), %rax
movl 0x80(%rax), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: reg2intervals_narrow
static inline int reg2intervals_narrow(hts_itr_t *iter, const bidx_t *bidx,
                                       int tid, int64_t beg, int64_t end,
                                       uint32_t interval,
                                       uint64_t min_off, uint64_t max_off,
                                       int min_shift, int n_lvls)
{
    int l, t, s = min_shift + n_lvls * 3;
    hts_pos_t b, e, i;

    for (--end, l = 0, t = 0; l <= n_lvls; s -= 3, t += 1<<((l<<1)+l), ++l) {
        b = t + (beg>>s); e = t + (end>>s);
        for (i = b; i <= e; ++i) {
            khint_t k = kh_get(bin, bidx, i);
            if (k != kh_end(bidx)) {
                bins_t *bin = &kh_value(bidx, k);
                int res = add_to_interval(iter, bin, tid, interval, min_off, max_off);
                if (res < 0)
                    return res;
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl 0x20(%rbp), %eax
imull $0x3, 0x28(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x38(%rbp), %eax
cmpl 0x28(%rbp), %eax
jg 0x28d90
movslq -0x3c(%rbp), %rax
movq -0x28(%rbp), %rdx
movl -0x40(%rbp), %ecx
sarq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movslq -0x3c(%rbp), %rax
movq -0x30(%rbp), %rdx
movl -0x40(%rbp), %ecx
sarq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x50(%rbp), %rax
jg 0x28d62
movq -0x18(%rbp), %rdi
movq -0x58(%rbp), %rax
movl %eax, %esi
callq 0x20ab0
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x28d52
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x5c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x34(%rbp), %ecx
movq 0x10(%rbp), %r8
movq 0x18(%rbp), %r9
callq 0x28f50
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jge 0x28d50
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x28d97
jmp 0x28d52
jmp 0x28d54
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x28ce7
jmp 0x28d64
movl -0x40(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x40(%rbp)
movl -0x38(%rbp), %ecx
shll %ecx
addl -0x38(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x28ca3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: swap_bins
static inline void swap_bins(bins_t *p)
{
    int i;
    for (i = 0; i < p->n; ++i) {
        ed_swap_8p(&p->list[i].u);
        ed_swap_8p(&p->list[i].v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x298ee
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x29860
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0x8, %rdi
callq 0x29860
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x298a3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts_expr.c
// Function: hts_filter_init
hts_filter_t *hts_filter_init(const char *str) {
    hts_filter_t *f = calloc(1, sizeof(*f));
    if (!f) return NULL;

    // Oversize to permit faster comparisons with memcmp over strcmp
    size_t len = strlen(str)+100;
    if (!(f->str = malloc(len))) {
        free(f);
        return NULL;
    }
    strcpy(f->str, str);
    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x298, %esi            # imm = 0x298
callq 0x42f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x29930
movq $0x0, -0x8(%rbp)
jmp 0x29982
movq -0x10(%rbp), %rdi
callq 0x41b0
addq $0x64, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4650
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x2996a
movq -0x18(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
jmp 0x29982
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4450
movq -0x18(%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/hts_expr.c
// Function: hts_filter_free
void hts_filter_free(hts_filter_t *filt) {
    if (!filt)
        return;

    int i;
    for (i = 0; i < filt->max_regex; i++)
        regfree(&filt->preg[i]);

    free(filt->str);
    free(filt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x299a5
jmp 0x299f0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x299db
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x44b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x299ac
movq -0x8(%rbp), %rax
movq (%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/hts_expr.c
// Function: hts_filter_eval
int hts_filter_eval(hts_filter_t *filt,
                    void *data, hts_expr_sym_func *fn,
                    hts_expr_val_t *res) {
    if (res->s.l != 0 || res->s.m != 0 || res->s.s != NULL) {
        // As *res is cleared below, it's not safe to call this function
        // with res->s.s set, as memory would be leaked.  It's also not
        // possible to know is res was initialised correctly, so in
        // either case we fail.
        hts_log_error("Results structure must be cleared before calling this function");
        return -1;
    }

    memset(res, 0, sizeof(*res));

    return hts_filter_eval_(filt, data, fn, res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x29a39
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x29a39
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x29a5c
movl $0x1, %edi
leaq 0xc74cb(%rip), %rsi     # 0xf0f10
leaq 0xc74d4(%rip), %rdx     # 0xf0f20
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29a84
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x4250
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x29a90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts_expr.c
// Function: hts_filter_eval_
static int hts_filter_eval_(hts_filter_t *filt,
                            void *data, hts_expr_sym_func *fn,
                            hts_expr_val_t *res) {
    char *end = NULL;

    filt->curr_regex = 0;
    if (expression(filt, data, fn, filt->str, &end, res))
        return -1;

    if (end && *ws(end)) {
        fprintf(stderr, "Unable to parse expression at %s\n", filt->str);
        return -1;
    }

    // Strings evaluate to true.  An empty string is also true, but an
    // absent (null) string is false, unless overriden by is_true.  An
    // empty string has kstring length of zero, but a pointer as it's
    // nul-terminated.
    if (res->is_str) {
        res->is_true |= res->s.s != NULL;
        res->d = res->is_true;
    } else if (hts_expr_val_exists(res)) {
        res->is_true |= res->d != 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 %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %r9
leaq -0x30(%rbp), %r8
callq 0x29c30
cmpl $0x0, %eax
je 0x29aec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29ba7
cmpq $0x0, -0x30(%rbp)
je 0x29b2c
movq -0x30(%rbp), %rdi
callq 0x29c80
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x29b2c
movq 0xe34d5(%rip), %rax     # 0x10cfe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xc7443(%rip), %rsi     # 0xf0f5f
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29ba7
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x29b66
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
setne %cl
movzbl %cl, %edx
movzbl 0x1(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x1(%rax)
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cvtsi2sd %eax, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x20(%rax)
jmp 0x29ba0
movq -0x28(%rbp), %rdi
callq 0x29ce0
cmpl $0x0, %eax
je 0x29b9e
movq -0x28(%rbp), %rax
movsd 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movzbl %al, %edx
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x1(%rax)
jmp 0x29ba0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/hts_expr.h
// Function: hts_expr_val_undef
static inline void hts_expr_val_undef(hts_expr_val_t *v) {
    ks_clear(&v->s);
    v->is_true = 0;
    v->is_str = 0;
    v->d = NAN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2c0d0
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movsd 0xc6734(%rip), %xmm0    # 0xf0eb8
movsd %xmm0, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts_expr.c
// Function: bitor_expr
static int bitor_expr(hts_filter_t *filt, void *data, hts_expr_sym_func *fn,
                      char *str, char **end, hts_expr_val_t *res) {
    if (bitxor_expr(filt, data, fn, str, end, res)) return -1;

    hts_expr_val_t val = HTS_EXPR_VAL_INIT;
    int undef = 0;
    for (;;) {
        str = ws(*end);
        if (*str == '|' && str[1] != '|') {
            if (bitxor_expr(filt, data, fn, str+1, end, &val)) return -1;
            if (!hts_expr_val_exists(&val) || !hts_expr_val_exists(res)) {
                undef = 1;
            } else if (res->is_str || val.is_str) {
                hts_expr_val_free(&val);
                return -1;
            } else {
                res->is_true =
                    (res->d = ((int64_t)res->d | (int64_t)val.d)) != 0;
            }
        } else {
            break;
        }
    }
    hts_expr_val_free(&val);
    if (undef)
        hts_expr_val_undef(res);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x2ae80
cmpl $0x0, %eax
je 0x2ad3e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ae6c
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x4250
movl $0x0, -0x64(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x29c80
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x2ae46
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x7c, %eax
je 0x2ae46
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq -0x30(%rbp), %r8
leaq -0x60(%rbp), %r9
callq 0x2ae80
cmpl $0x0, %eax
je 0x2adb8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ae6c
leaq -0x60(%rbp), %rdi
callq 0x29ce0
cmpl $0x0, %eax
je 0x2add4
movq -0x38(%rbp), %rdi
callq 0x29ce0
cmpl $0x0, %eax
jne 0x2addd
movl $0x1, -0x64(%rbp)
jmp 0x2ae44
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2adf2
movsbl -0x60(%rbp), %eax
cmpl $0x0, %eax
je 0x2ae04
leaq -0x60(%rbp), %rdi
callq 0x2a790
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ae6c
movq -0x38(%rbp), %rax
cvttsd2si 0x20(%rax), %rax
cvttsd2si -0x40(%rbp), %rcx
orq %rcx, %rax
cvtsi2sd %rax, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x20(%rax)
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x1(%rax)
jmp 0x2ae44
jmp 0x2ae48
jmp 0x2ae4d
jmp 0x2ad55
leaq -0x60(%rbp), %rdi
callq 0x2a790
cmpl $0x0, -0x64(%rbp)
je 0x2ae65
movq -0x38(%rbp), %rdi
callq 0x2a750
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts_expr.c
// Function: expr_func_avg
static int expr_func_avg(hts_expr_val_t *res) {
    if (!res->is_str)
        return -1;

    size_t l = res->s.l;
    double v = 0;
    const uint8_t *x = (uint8_t *)res->s.s;
    for (l = 0; l < res->s.l; l++)
        v += x[l];
    if (l)
        v /= l;

    res->is_str = 0;
    res->d = v;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2c93d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2c9f3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2c99b
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cvtsi2sd %eax, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2c965
cmpq $0x0, -0x18(%rbp)
je 0x2c9d7
movaps 0xc2f57(%rip), %xmm0    # 0xef900
movq -0x18(%rbp), %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0xc2f56(%rip), %xmm0    # 0xef910
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts_expr.c
// Function: expr_func_length
static int expr_func_length(hts_expr_val_t *res) {
    if (!res->is_str)
        return -1;

    res->is_str = 0;
    res->d = res->s.l;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2ca1a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ca5c
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %xmm0
movaps 0xc2ecf(%rip), %xmm1    # 0xef900
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xc2ed3(%rip), %xmm1    # 0xef910
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts_expr.c
// Function: expr_func_min
static int expr_func_min(hts_expr_val_t *res) {
    if (!res->is_str)
        return -1;

    size_t l = res->s.l;
    int v = INT_MAX;
    const uint8_t *x = (uint8_t *)res->s.s;
    for (l = 0; l < res->s.l; l++)
        if (v > x[l])
            v = x[l];

    res->is_str = 0;
    res->d = v == INT_MAX ? NAN : v;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2ca8d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2cb36
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x7fffffff, -0x1c(%rbp) # imm = 0x7FFFFFFF
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2caf4
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x2cae4
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2cae6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2cab4
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x7fffffff, -0x1c(%rbp) # imm = 0x7FFFFFFF
jne 0x2cb13
movss 0xc4400(%rip), %xmm0    # 0xf0f0c
movss %xmm0, -0x2c(%rbp)
jmp 0x2cb1d
cvtsi2ssl -0x1c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts_expr.c
// Function: expr_func_max
static int expr_func_max(hts_expr_val_t *res) {
    if (!res->is_str)
        return -1;

    size_t l = res->s.l;
    int v = INT_MIN;
    const uint8_t *x = (uint8_t *)res->s.s;
    for (l = 0; l < res->s.l; l++)
        if (v < x[l])
            v = x[l];

    res->is_str = 0;
    res->d = v == INT_MIN ? NAN : v;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2cb5d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2cc06
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x80000000, -0x1c(%rbp) # imm = 0x80000000
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2cbc4
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x2cbb4
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2cbb6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2cb84
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x80000000, -0x1c(%rbp) # imm = 0x80000000
jne 0x2cbe3
movss 0xc4330(%rip), %xmm0    # 0xf0f0c
movss %xmm0, -0x2c(%rbp)
jmp 0x2cbed
cvtsi2ssl -0x1c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/multipart.c
// Function: hopen_htsget_redirect
hFILE *hopen_htsget_redirect(hFILE *hfile, const char *mode)
{
    hFILE_multipart *fp;
    kstring_t s1 = { 0, 0, NULL }, s2 = { 0, 0, NULL };
    char ret;

    fp = (hFILE_multipart *) hfile_init(sizeof (hFILE_multipart), mode, 0);
    if (fp == NULL) return NULL;

    fp->parts = NULL;
    fp->nparts = fp->maxparts = 0;

    ret = parse_ga4gh_redirect_json(fp, hfile, &s1, &s2);
    free(s1.s);
    free(s2.s);
    if (ret != 'v') {
        free_all_parts(fp);
        hfile_destroy((hFILE *) fp);
        errno = (ret == '?' || ret == '\0')? EPROTO : EINVAL;
        return NULL;
    }

    fp->current = 0;
    fp->currentfp = NULL;
    fp->base.backend = &multipart_backend;
    return &fp->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4250
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4250
movq -0x18(%rbp), %rsi
movl $0x60, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x13800
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2cc9a
movq $0x0, -0x8(%rbp)
jmp 0x2cd77
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x2cd90
movb %al, -0x51(%rbp)
movq -0x28(%rbp), %rdi
callq 0x45a0
movq -0x40(%rbp), %rdi
callq 0x45a0
movsbl -0x51(%rbp), %eax
cmpl $0x76, %eax
je 0x2cd48
movq -0x20(%rbp), %rdi
callq 0x2ce70
movq -0x20(%rbp), %rdi
callq 0x13980
movsbl -0x51(%rbp), %ecx
movb $0x1, %al
cmpl $0x3f, %ecx
movb %al, -0x52(%rbp)
je 0x2cd1e
movsbl -0x51(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %dl
movl $0x16, %eax
movl $0x47, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x58(%rbp)
callq 0x4050
movl -0x58(%rbp), %ecx
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x2cd77
movq -0x20(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x20(%rbp), %rax
leaq 0xdffa5(%rip), %rcx     # 0x10cd10
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/multipart.c
// Function: parse_ga4gh_redirect_json
static char
parse_ga4gh_redirect_json(hFILE_multipart *fp, hFILE *json,
                          kstring_t *b, kstring_t *header) {
    hts_json_token t;

    if (hts_json_fnext(json, &t, b) != '{') return t.type;
    while (hts_json_fnext(json, &t, b) != '}') {
        if (t.type != 's') return '?';

        if (strcmp(t.str, "htsget") == 0) {
            char ret = parse_ga4gh_body_json(fp, json, b, header);
            if (ret != 'v') return ret;
        }
        else return '?';
    }

    if (hts_json_fnext(json, &t, b) != '\0') return '?';

    return 'v';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x4bed0
movsbl %al, %eax
cmpl $0x7b, %eax
je 0x2cdcc
movb -0x38(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x2ce61
jmp 0x2cdce
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x4bed0
movsbl %al, %eax
cmpl $0x7d, %eax
je 0x2ce3e
movsbl -0x38(%rbp), %eax
cmpl $0x73, %eax
je 0x2cdf6
movb $0x3f, -0x1(%rbp)
jmp 0x2ce61
movq -0x30(%rbp), %rdi
leaq 0xc325a(%rip), %rsi     # 0xf005b
callq 0x4690
cmpl $0x0, %eax
jne 0x2ce36
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2ced0
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0x76, %eax
je 0x2ce34
movb -0x39(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x2ce61
jmp 0x2ce3c
movb $0x3f, -0x1(%rbp)
jmp 0x2ce61
jmp 0x2cdce
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x4bed0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x2ce5d
movb $0x3f, -0x1(%rbp)
jmp 0x2ce61
movb $0x76, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/multipart.c
// Function: free_part
static void free_part(hfile_part *p)
{
    free(p->url);
    if (p->headers) {
        char **hdr;
        for (hdr = p->headers; *hdr; hdr++) free(*hdr);
        free(p->headers);
    }

    p->url = NULL;
    p->headers = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2d570
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2d563
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x45a0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x2d53f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq $0x0, (%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/multipart.c
// Function: multipart_close
static int multipart_close(hFILE *fpv)
{
    hFILE_multipart *fp = (hFILE_multipart *) fpv;

    free_all_parts(fp);
    if (fp->currentfp) {
        if (hclose(fp->currentfp) < 0) return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2ce70
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x2d895
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x14920
cmpl $0x0, %eax
jge 0x2d893
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d89c
jmp 0x2d895
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/regidx.c
// Function: regidx_insert_list
int regidx_insert_list(regidx_t *idx, char *line, char delim)
{
    kstring_t tmp = KS_INITIALIZE;
    char *ss = line;
    while ( *ss )
    {
        char *se = ss;
        while ( *se && *se!=delim ) se++;
        kputsn(ss, se-ss, ks_clear(&tmp));
        if ( regidx_insert(idx,tmp.s) < 0 )
        {
            ks_free(&tmp);
            return -1;
        }
        if ( !*se ) break;
        ss = se+1;
    }
    ks_free(&tmp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4250
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2dbbd
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
je 0x2db36
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x2db3f
jmp 0x2db4d
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x2db12
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2dc90
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x2dbe0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2dcb0
cmpl $0x0, %eax
jge 0x2dba1
leaq -0x38(%rbp), %rdi
callq 0x2dd50
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2dbcd
movq -0x48(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2dbac
jmp 0x2dbbd
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2dafd
leaq -0x38(%rbp), %rdi
callq 0x2dd50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/regidx.c
// Function: regidx_insert
int regidx_insert(regidx_t *idx, char *line)
{
    if ( !line ) return 0;
    char *chr_from, *chr_to;
    hts_pos_t beg,end;
    int ret = idx->parse(line,&chr_from,&chr_to,&beg,&end,idx->payload,idx->usr);
    if ( ret==-2 ) return -1;   // error
    if ( ret==-1 ) return 0;    // skip the line
    return regidx_push(idx, chr_from,chr_to,beg,end,idx->payload);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2dcd0
movl $0x0, -0x4(%rbp)
jmp 0x2dd47
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %r9
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %r10
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
movq %r10, (%rsp)
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $-0x2, -0x3c(%rbp)
jne 0x2dd14
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2dd47
cmpl $-0x1, -0x3c(%rbp)
jne 0x2dd23
movl $0x0, -0x4(%rbp)
jmp 0x2dd47
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %r9
callq 0x2dd80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/khash_str2int.h
// Function: khash_str2int_inc
static inline int khash_str2int_inc(void *_hash, const char *str)
{
    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;
    if (ret == 0) return kh_val(hash, k);
    kh_val(hash, k) = kh_size(hash) - 1;
    return kh_val(hash, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2e1d8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e23d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x300d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x2e1fb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e23d
cmpl $0x0, -0x20(%rbp)
jne 0x2e214
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x2e23d
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
subl $0x1, %edx
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %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/regidx.c
// Function: cmp_regs
static inline int cmp_regs(reg_t *a, reg_t *b)
{
    if ( a->beg < b->beg ) return -1;
    if ( a->beg > b->beg ) return 1;
    if ( a->end < b->end ) return 1;    // longer intervals come first
    if ( a->end > b->end ) return -1;
    if ( a < b ) return -1; // this is are just for qsort reproducibility across platforms
    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 -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x2e275
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e2f1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x2e28e
movl $0x1, -0x4(%rbp)
jmp 0x2e2f1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x2e2a9
movl $0x1, -0x4(%rbp)
jmp 0x2e2f1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x2e2c4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e2f1
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2e2d7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e2f1
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x2e2ea
movl $0x1, -0x4(%rbp)
jmp 0x2e2f1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)