LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hfile.c
// Function: knet_dopen
HTSLIB_EXPORT
knetFile *knet_dopen(int fd, const char *mode) {
    knetFile *fp = calloc(1, sizeof(*fp));
    if (!fp) return NULL;
    if (!(fp->hf = hdopen(fd, mode))) {
        free(fp);
        return NULL;
    }
    fp->fd = fd;
    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x88, %esi
callq 0x42f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x16103
movq $0x0, -0x8(%rbp)
jmp 0x16145
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x14a40
movq -0x20(%rbp), %rcx
movq %rax, 0x80(%rcx)
cmpq $0x0, %rax
jne 0x16133
movq -0x20(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
jmp 0x16145
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hfile.c
// Function: knet_seek
HTSLIB_EXPORT
off_t knet_seek(knetFile *fp, off_t off, int whence) {
    off_t r = hseek(fp->hf, off, whence);
    if (r >= 0)
        fp->offset = r;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x146a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x162b1
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hfile.c
// Function: fd_read
static ssize_t fd_read(hFILE *fpv, void *buffer, size_t nbytes)
{
    hFILE_fd *fp = (hFILE_fd *) fpv;
    ssize_t n;
    do {
        n = fp->is_socket? recv(fp->fd, buffer, nbytes, 0)
                         : read(fp->fd, buffer, nbytes);
    } while (n < 0 && errno == EINTR);
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x3c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x16349
movq -0x20(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4120
movq %rax, -0x30(%rbp)
jmp 0x16361
movq -0x20(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x46e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
jge 0x16383
callq 0x4050
cmpl $0x4, (%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1631c
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hfile.c
// Function: fd_write
static ssize_t fd_write(hFILE *fpv, const void *buffer, size_t nbytes)
{
    hFILE_fd *fp = (hFILE_fd *) fpv;
    ssize_t n;
    do {
        n = fp->is_socket?  send(fp->fd, buffer, nbytes, 0)
                         : write(fp->fd, buffer, nbytes);
    } while (n < 0 && errno == EINTR);
#ifdef _WIN32
        // On windows we have no SIGPIPE.  Instead write returns
        // EINVAL.  We check for this and our fd being a pipe.
        // If so, we raise SIGTERM instead of SIGPIPE.  It's not
        // ideal, but I think the only alternative is extra checking
        // in every single piece of code.
        if (n < 0 && errno == EINVAL &&
            GetLastError() == ERROR_NO_DATA &&
            GetFileType((HANDLE)_get_osfhandle(fp->fd)) == FILE_TYPE_PIPE) {
            raise(SIGTERM);
        }
#endif
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x3c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x163e9
movq -0x20(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4220
movq %rax, -0x30(%rbp)
jmp 0x16401
movq -0x20(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4160
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
jge 0x16423
callq 0x4050
cmpl $0x4, (%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x163bc
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hfile.c
// Function: fd_flush
static int fd_flush(hFILE *fpv)
{
    int ret = 0;
    do {
#ifdef HAVE_FDATASYNC
        hFILE_fd *fp = (hFILE_fd *) fpv;
        ret = fdatasync(fp->fd);
#elif defined(HAVE_FSYNC)
        hFILE_fd *fp = (hFILE_fd *) fpv;
        ret = fsync(fp->fd);
#endif
        // Ignore invalid-for-fsync(2) errors due to being, e.g., a pipe,
        // and operation-not-supported errors (Mac OS X)
        if (ret < 0 && (errno == EINVAL || errno == ENOTSUP)) ret = 0;
    } while (ret < 0 && errno == EINTR);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x164b4
callq 0x4050
cmpl $0x16, (%rax)
je 0x164ad
callq 0x4050
cmpl $0x5f, (%rax)
jne 0x164b4
movl $0x0, -0xc(%rbp)
jmp 0x164b6
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jge 0x164cf
callq 0x4050
cmpl $0x4, (%rax)
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x16493
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hfile.c
// Function: fd_close
static int fd_close(hFILE *fpv)
{
    hFILE_fd *fp = (hFILE_fd *) fpv;
    int ret;

    // If we don't own the fd, return successfully without actually closing it
    if (fp->is_shared) return 0;

    do {
#ifdef HAVE_CLOSESOCKET
        ret = fp->is_socket? closesocket(fp->fd) : close(fp->fd);
#else
        ret = close(fp->fd);
#endif
    } while (ret < 0 && errno == EINTR);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb 0x3c(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x16510
movl $0x0, -0x4(%rbp)
jmp 0x16547
jmp 0x16512
movq -0x18(%rbp), %rax
movl 0x38(%rax), %edi
callq 0x49c0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jge 0x1653a
callq 0x4050
cmpl $0x4, (%rax)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x16512
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hfile.c
// Function: create_hfile_mem
static hFILE *create_hfile_mem(char* buffer, const char* mode, size_t buf_filled, size_t buf_size)
{
    hFILE_mem *fp = (hFILE_mem *) hfile_init_fixed(sizeof(hFILE_mem), mode, buffer, buf_filled, buf_size);
    if (fp == NULL)
        return NULL;

    fp->base.backend = &mem_backend;
    return &fp->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x38, %edi
callq 0x139d0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x165d7
movq $0x0, -0x8(%rbp)
jmp 0x165ee
movq -0x30(%rbp), %rax
leaq 0xf6616(%rip), %rcx     # 0x10cbf8
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hfile.c
// Function: hopen_mem
static hFILE *hopen_mem(const char *url, const char *mode)
{
    size_t length, size;
    char *buffer;
    const char *data, *comma = strchr(url, ',');
    if (comma == NULL) { errno = EINVAL; return NULL; }
    data = comma+1;

    // TODO Implement write modes
    if (strchr(mode, 'r') == NULL) { errno = EROFS; return NULL; }

    if (comma - url >= 7 && cmp_prefix(";base64", &comma[-7]) == 0) {
        size = hts_base64_decoded_length(strlen(data));
        buffer = malloc(size);
        if (buffer == NULL) return NULL;
        hts_decode_base64(buffer, &length, data);
    }
    else {
        size = strlen(data) + 1;
        buffer = malloc(size);
        if (buffer == NULL) return NULL;
        hts_decode_percent(buffer, &length, data);
    }
    hFILE* hf;

    if(!(hf = create_hfile_mem(buffer, mode, length, size))){
        free(buffer);
        return NULL;
    }

    return hf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x4170
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x16ba1
callq 0x4050
movl $0x16, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x16cc6
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl $0x72, %esi
callq 0x4170
cmpq $0x0, %rax
jne 0x16bd9
callq 0x4050
movl $0x1e, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x16cc6
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x7, %rax
jl 0x16c4c
movq -0x40(%rbp), %rsi
addq $-0x7, %rsi
leaq 0xd8c42(%rip), %rdi     # 0xef83b
callq 0x16f30
cmpl $0x0, %eax
jne 0x16c4c
movq -0x38(%rbp), %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x4b670
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4650
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x16c39
movq $0x0, -0x8(%rbp)
jmp 0x16cc6
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x4b690
jmp 0x16c8c
movq -0x38(%rbp), %rdi
callq 0x41b0
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4650
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x16c7b
movq $0x0, -0x8(%rbp)
jmp 0x16cc6
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x4b510
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x16590
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x16cbe
movq -0x30(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
jmp 0x16cc6
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hfile.c
// Function: hopen_fd_fileuri
static hFILE *hopen_fd_fileuri(const char *url, const char *mode)
{
    if (strncmp(url, "file://localhost/", 17) == 0) url += 16;
    else if (strncmp(url, "file:///", 8) == 0) url += 7;
    else { errno = EPROTONOSUPPORT; return NULL; }

#if defined(_WIN32) || defined(__MSYS__)
    // For cases like C:/foo
    if (url[0] == '/' && url[1] && url[2] == ':' && url[3] == '/') url++;
#endif

    return hopen_fd(url, mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd8b58(%rip), %rsi     # 0xef843
movl $0x11, %edx
callq 0x4200
cmpl $0x0, %eax
jne 0x16d08
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x16d47
movq -0x10(%rbp), %rdi
leaq 0xd8b42(%rip), %rsi     # 0xef855
movl $0x8, %edx
callq 0x4200
cmpl $0x0, %eax
jne 0x16d30
movq -0x10(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x10(%rbp)
jmp 0x16d45
callq 0x4050
movl $0x5d, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x16d58
jmp 0x16d47
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15bf0
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/hfile.c
// Function: init_add_plugin
static int init_add_plugin(void *obj, int (*init)(struct hFILE_plugin *),
                           const char *pluginname)
{
    struct hFILE_plugin_list *p = malloc (sizeof (struct hFILE_plugin_list));
    if (p == NULL) {
        hts_log_debug("Failed to allocate memory for plugin \"%s\"", pluginname);
        return -1;
    }

    p->plugin.api_version = 1;
    p->plugin.obj = obj;
    p->plugin.name = NULL;
    p->plugin.destroy = NULL;

    int ret = (*init)(&p->plugin);

    if (ret != 0) {
        hts_log_debug("Initialisation failed for plugin \"%s\": %d", pluginname, ret);
        free(p);
        return ret;
    }

    hts_log_debug("Loaded \"%s\"", pluginname);

    p->next = plugins, plugins = p;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x28, %edi
callq 0x4650
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x16e53
movq -0x20(%rbp), %rcx
movl $0x5, %edi
leaq 0xd8a25(%rip), %rsi     # 0xef85e
leaq 0xd8a2e(%rip), %rdx     # 0xef86e
movb $0x0, %al
callq 0x1b030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16f06
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x16ec7
movq -0x20(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl $0x5, %edi
leaq 0xd89b6(%rip), %rsi     # 0xef85e
leaq 0xd89e9(%rip), %rdx     # 0xef898
movb $0x0, %al
callq 0x1b030
movq -0x28(%rbp), %rdi
callq 0x45a0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16f06
movq -0x20(%rbp), %rcx
movl $0x5, %edi
leaq 0xd8987(%rip), %rsi     # 0xef85e
leaq 0xd89e4(%rip), %rdx     # 0xef8c2
movb $0x0, %al
callq 0x1b030
movq 0xfb0b4(%rip), %rcx     # 0x111fa0
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq %rax, 0xfb0a1(%rip)     # 0x111fa0
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/hfile.c
// Function: cmp_prefix
static int cmp_prefix(const char *key, const char *s)
{
    while (*key)
        if (tolower_c(*s) != *key) return +1;
        else s++, key++;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x16f86
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x16fa0
movsbl %al, %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x16f6c
movl $0x1, -0x4(%rbp)
jmp 0x16f8d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x16f40
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/hfile.c
// Function: hpreload
static hFILE *hpreload(hFILE *fp) {
    hFILE *mem_fp;
    char *buf = NULL;
    off_t buf_sz = 0, buf_a = 0, buf_inc = 8192, len;

    for (;;) {
        if (buf_a - buf_sz < 5000) {
            buf_a += buf_inc;
            char *t = realloc(buf, buf_a);
            if (!t) goto err;
            buf = t;
            if (buf_inc < 1000000) buf_inc *= 1.3;
        }
        len = hread(fp, buf+buf_sz, buf_a-buf_sz);
        if (len > 0)
            buf_sz += len;
        else
            break;
    }

    if (len < 0) goto err;
    mem_fp = hfile_init_fixed(sizeof(hFILE), "r", buf, buf_sz, buf_a);
    if (!mem_fp) goto err;
    mem_fp->backend = &mem_backend;

    if (hclose(fp) < 0) {
        hclose_abruptly(mem_fp);
        goto err;
    }
    return mem_fp;

 err:
    free(buf);
    hclose_abruptly(fp);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x2000, -0x38(%rbp)    # imm = 0x2000
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
cmpq $0x1388, %rax           # imm = 0x1388
jge 0x17054
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4820
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x17025
jmp 0x170f2
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0xf4240, -0x38(%rbp)   # imm = 0xF4240
jge 0x17052
cvtsi2sdq -0x38(%rbp), %xmm0
movsd 0xd85eb(%rip), %xmm1    # 0xef630
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x38(%rbp)
jmp 0x17054
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
subq -0x28(%rbp), %rdx
callq 0x161c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jle 0x17086
movq -0x40(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x17088
jmp 0x1708d
jmp 0x16fec
cmpq $0x0, -0x40(%rbp)
jge 0x17096
jmp 0x170f2
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x38, %edi
leaq 0xdba43(%rip), %rsi     # 0xf2af1
callq 0x139d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x170c0
jmp 0x170f2
movq -0x18(%rbp), %rax
leaq 0xf5b2d(%rip), %rcx     # 0x10cbf8
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x14920
cmpl $0x0, %eax
jge 0x170e8
movq -0x18(%rbp), %rdi
callq 0x149d0
jmp 0x170f2
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1710c
movq -0x20(%rbp), %rdi
callq 0x45a0
movq -0x10(%rbp), %rdi
callq 0x149d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: decompress_peek_gz
static ssize_t
decompress_peek_gz(hFILE *fp, unsigned char *dest, size_t destsize)
{
    unsigned char buffer[2048];
    z_stream zs;
    ssize_t npeek = hpeek(fp, buffer, sizeof buffer);

    if (npeek < 0) return -1;

    zs.zalloc = NULL;
    zs.zfree = NULL;
    zs.next_in = buffer;
    zs.avail_in = npeek;
    zs.next_out = dest;
    zs.avail_out = destsize;
    if (inflateInit2(&zs, 31) != Z_OK) return -1;

    int ret;
    const unsigned char *last_in = buffer;
    while (zs.avail_out > 0) {
        ret = inflate(&zs, Z_SYNC_FLUSH);
        if (ret == Z_STREAM_END) {
            if (last_in == zs.next_in)
                break; // Paranoia to avoid potential looping. Shouldn't happen
            else
                last_in = zs.next_in;
            inflateReset(&zs);
        } else if (ret != Z_OK) {
            // eg Z_BUF_ERROR due to avail_in/out becoming zero
            break;
        }
    }

    // NB: zs.total_out is changed by inflateReset, so use pointer diff instead
    destsize = zs.next_out - dest;
    inflateEnd(&zs);

    return destsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8b0, %rsp            # imm = 0x8B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x820(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x140b0
movq %rax, -0x898(%rbp)
cmpq $0x0, -0x898(%rbp)
jge 0x1909a
movq $-0x1, -0x8(%rbp)
jmp 0x191a9
movq $0x0, -0x850(%rbp)
movq $0x0, -0x848(%rbp)
leaq -0x820(%rbp), %rax
movq %rax, -0x890(%rbp)
movq -0x898(%rbp), %rax
movl %eax, -0x888(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x878(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x870(%rbp)
leaq -0x890(%rbp), %rdi
movl $0x1f, %esi
leaq 0xd5a92(%rip), %rdx     # 0xeeb85
movl $0x70, %ecx
callq 0x43d0
cmpl $0x0, %eax
je 0x1910f
movq $-0x1, -0x8(%rbp)
jmp 0x191a9
leaq -0x820(%rbp), %rax
movq %rax, -0x8a8(%rbp)
cmpl $0x0, -0x870(%rbp)
jbe 0x19183
leaq -0x890(%rbp), %rdi
movl $0x2, %esi
callq 0x4370
movl %eax, -0x89c(%rbp)
cmpl $0x1, -0x89c(%rbp)
jne 0x19174
movq -0x8a8(%rbp), %rax
cmpq -0x890(%rbp), %rax
jne 0x19158
jmp 0x19183
movq -0x890(%rbp), %rax
movq %rax, -0x8a8(%rbp)
leaq -0x890(%rbp), %rdi
callq 0x46b0
jmp 0x19181
cmpl $0x0, -0x89c(%rbp)
je 0x1917f
jmp 0x19183
jmp 0x19181
jmp 0x1911d
movq -0x878(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq -0x890(%rbp), %rdi
callq 0x44c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8b0, %rsp            # imm = 0x8B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: decompress_peek_xz
static ssize_t
decompress_peek_xz(hFILE *fp, unsigned char *dest, size_t destsize)
{
    unsigned char buffer[2048];
    ssize_t npeek = hpeek(fp, buffer, sizeof buffer);
    if (npeek < 0) return -1;

    lzma_stream ls = LZMA_STREAM_INIT;
    if (lzma_stream_decoder(&ls, lzma_easy_decoder_memusage(9), 0) != LZMA_OK)
        return -1;

    ls.next_in = buffer;
    ls.avail_in = npeek;
    ls.next_out = dest;
    ls.avail_out = destsize;

    int r = lzma_code(&ls, LZMA_RUN);
    if (! (r == LZMA_OK || r == LZMA_STREAM_END)) {
        lzma_end(&ls);
        return -1;
    }

    destsize = ls.total_out;
    lzma_end(&ls);

    return destsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8c0, %rsp            # imm = 0x8C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x820(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x140b0
movq %rax, -0x828(%rbp)
cmpq $0x0, -0x828(%rbp)
jge 0x1920a
movq $-0x1, -0x8(%rbp)
jmp 0x192d7
leaq -0x8b0(%rbp), %rdi
xorl %esi, %esi
movl $0x88, %edx
callq 0x4250
movl $0x9, %edi
callq 0x4980
movq %rax, %rsi
leaq -0x8b0(%rbp), %rdi
xorl %edx, %edx
callq 0x40f0
cmpl $0x0, %eax
je 0x1924a
movq $-0x1, -0x8(%rbp)
jmp 0x192d7
leaq -0x820(%rbp), %rax
movq %rax, -0x8b0(%rbp)
movq -0x828(%rbp), %rax
movq %rax, -0x8a8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x898(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x890(%rbp)
leaq -0x8b0(%rbp), %rdi
xorl %esi, %esi
callq 0x4190
movl %eax, -0x8b4(%rbp)
cmpl $0x0, -0x8b4(%rbp)
je 0x192b8
cmpl $0x1, -0x8b4(%rbp)
je 0x192b8
leaq -0x8b0(%rbp), %rdi
callq 0x4710
movq $-0x1, -0x8(%rbp)
jmp 0x192d7
movq -0x888(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x8b0(%rbp), %rdi
callq 0x4710
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8c0, %rsp            # imm = 0x8C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: parse_version
static void
parse_version(htsFormat *fmt, const unsigned char *u, const unsigned char *ulim)
{
    const char *s    = (const char *) u;
    const char *slim = (const char *) ulim;
    short v;

    fmt->version.major = fmt->version.minor = -1;

    for (v = 0; s < slim && isdigit_c(*s); s++)
        v = 10 * v + *s - '0';

    if (s < slim) {
        fmt->version.major = v;
        if (*s == '.') {
            s++;
            for (v = 0; s < slim && isdigit_c(*s); s++)
                v = 10 * v + *s - '0';
            if (s < slim)
                fmt->version.minor = v;
        }
        else
            fmt->version.minor = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movw $0xffff, 0xa(%rax)      # imm = 0xFFFF
movq -0x8(%rbp), %rax
movw $0xffff, 0x8(%rax)      # imm = 0xFFFF
movw $0x0, -0x2a(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x2b(%rbp)
jae 0x19592
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x23470
cmpl $0x0, %eax
setne %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
testb $0x1, %al
jne 0x1959b
jmp 0x195c0
movswl -0x2a(%rbp), %eax
imull $0xa, %eax, %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movw %ax, -0x2a(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1956e
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1966e
movw -0x2a(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x19662
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movw $0x0, -0x2a(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x2c(%rbp)
jae 0x1961c
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x23470
cmpl $0x0, %eax
setne %al
movb %al, -0x2c(%rbp)
movb -0x2c(%rbp), %al
testb $0x1, %al
jne 0x19625
jmp 0x1964a
movswl -0x2a(%rbp), %eax
imull $0xa, %eax, %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movw %ax, -0x2a(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x195f8
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x19660
movw -0x2a(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0xa(%rax)
jmp 0x1966c
movq -0x8(%rbp), %rax
movw $0x0, 0xa(%rax)
jmp 0x1966e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: cmp_nonblank
static int
cmp_nonblank(const char *key, const unsigned char *u, const unsigned char *ulim)
{
    const unsigned char *ukey = (const unsigned char *) key;

    while (*ukey)
        if (u >= ulim) return +1;
        else if (isspace_c(*u)) u++;
        else if (*u != *ukey) return (*ukey < *u)? -1 : +1;
        else u++, ukey++;

    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)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x19730
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x196bc
movl $0x1, -0x4(%rbp)
jmp 0x19737
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x23440
cmpl $0x0, %eax
je 0x196db
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x19729
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x1970f
movq -0x28(%rbp), %rax
movzbl (%rax), %edx
movq -0x18(%rbp), %rax
movzbl (%rax), %esi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x19737
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x19729
jmp 0x1972b
jmp 0x1969c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: is_fastaq
static int is_fastaq(const unsigned char *u, const unsigned char *ulim)
{
    const unsigned char *eol = memchr(u, '\n', ulim - u);

    // Check that the first line is entirely textual
    if (! is_text_only(u, eol? eol : ulim)) return 0;

    // If the first line is very long, consider the file to indeed be FASTA/Q
    if (eol == NULL) return 1;

    u = eol+1; // Now points to the first character of the second line

    // Scan over all base-encoding letters (including 'N' but not SEQ's '=')
    while (u < ulim && (seq_nt16_table[*u] != 15 || toupper(*u) == 'N')) {
        if (*u == '=') return 0;
        u++;
    }

    return (u == ulim || *u == '\r' || *u == '\n')? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movl $0xa, %esi
callq 0x4530
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x19786
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x1978e
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x19b80
cmpl $0x0, %eax
jne 0x197ac
movl $0x0, -0x4(%rbp)
jmp 0x19882
cmpq $0x0, -0x20(%rbp)
jne 0x197bf
movl $0x1, -0x4(%rbp)
jmp 0x19882
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x19813
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xd6346(%rip), %rax     # 0xefb30
movzbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xf, %ecx
movb %al, -0x32(%rbp)
jne 0x1980d
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x4950
cmpl $0x4e, %eax
sete %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1981c
jmp 0x1983f
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x19831
movl $0x0, -0x4(%rbp)
jmp 0x19882
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x197cb
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq -0x18(%rbp), %rcx
movb %al, -0x33(%rbp)
je 0x1986f
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x33(%rbp)
je 0x1986f
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x33(%rbp)
movb -0x33(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: colmatch
static int colmatch(const char *columns, const char *pattern)
{
    int i;
    for (i = 0; columns[i] != '\0'; i++) {
        if (pattern[i] == '+') return i;
        if (! (columns[i] == pattern[i] || pattern[i] == 'Z')) return 0;
    }

    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x19b70
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0x19b2d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x19b76
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x19b63
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
je 0x19b63
movl $0x0, -0x4(%rbp)
jmp 0x19b76
jmp 0x19b65
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19b03
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: is_text_only
static int is_text_only(const unsigned char *u, const unsigned char *ulim)
{
    for (; u < ulim; u++)
        if (! (*u >= ' ' || *u == '\t' || *u == '\r' || *u == '\n'))
            return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x19bdf
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jge 0x19bcf
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
je 0x19bcf
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0x19bcf
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x19bcf
movl $0x0, -0x4(%rbp)
jmp 0x19be6
jmp 0x19bd1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x19b8c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/./htslib/kstring.h
// Function: ks_release
static inline char *ks_release(kstring_t *s)
{
	char *ss = s->s;
	s->l = s->m = 0;
	s->s = NULL;
	return ss;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_opt_apply
int hts_opt_apply(htsFile *fp, hts_opt *opts) {
    hts_opt *last = NULL;

    for (; opts;  opts = (last=opts)->next) {
        switch (opts->opt) {
            case CRAM_OPT_REFERENCE:
                if (!(fp->fn_aux = strdup(opts->val.s)))
                    return -1;
                // fall through
            case CRAM_OPT_VERSION:
            case CRAM_OPT_PREFIX:
            case HTS_OPT_FILTER:
            case FASTQ_OPT_AUX:
            case FASTQ_OPT_BARCODE:
                if (hts_set_opt(fp,  opts->opt,  opts->val.s) != 0)
                    return -1;
                break;
            default:
                if (hts_set_opt(fp,  opts->opt,  opts->val.i) != 0)
                    return -1;
                break;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1b01a
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x1afb0
jmp 0x1af54
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x1afb0
jmp 0x1af5e
movl -0x24(%rbp), %eax
subl $0x9, %eax
je 0x1af8a
jmp 0x1af68
movl -0x24(%rbp), %eax
subl $0x69, %eax
je 0x1afb0
jmp 0x1af72
movl -0x24(%rbp), %eax
subl $0x3e9, %eax            # imm = 0x3E9
je 0x1afb0
jmp 0x1af7e
movl -0x24(%rbp), %eax
subl $0x3eb, %eax            # imm = 0x3EB
je 0x1afb0
jmp 0x1afda
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4920
movq -0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x1afae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b021
jmp 0x1afb0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movb $0x0, %al
callq 0x1bf80
cmpl $0x0, %eax
je 0x1afd8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b021
jmp 0x1b003
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movb $0x0, %al
callq 0x1bf80
cmpl $0x0, %eax
je 0x1b001
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b021
jmp 0x1b003
jmp 0x1b005
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1af38
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_log
void hts_log(enum htsLogLevel severity, const char *context, const char *format, ...)
{
    int save_errno = errno;
    if (severity <= hts_verbose) {
        va_list argptr;

        fprintf(stderr, "[%c::%s] ", get_severity_tag(severity), context);

        va_start(argptr, format);
        vfprintf(stderr, format, argptr);
        va_end(argptr);

        fprintf(stderr, "\n");
    }
    errno = save_errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x1b06b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x4050
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xf26f2(%rip), %eax     # 0x10d790
ja 0x1b130
movq 0xf1f35(%rip), %rax     # 0x10cfe0
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movl -0x4(%rbp), %edi
callq 0x26c90
movq -0xf8(%rbp), %rdi
movsbl %al, %edx
movq -0x10(%rbp), %rcx
leaq 0xd5b82(%rip), %rsi     # 0xf0c54
movb $0x0, %al
callq 0x46d0
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0xf1edc(%rip), %rax     # 0x10cfe0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4660
leaq -0x40(%rbp), %rax
movq 0xf1ec1(%rip), %rax     # 0x10cfe0
movq (%rax), %rdi
leaq 0xd3884(%rip), %rsi     # 0xee9ad
movb $0x0, %al
callq 0x46d0
movl -0x1c(%rbp), %eax
movl %eax, -0xfc(%rbp)
callq 0x4050
movl -0xfc(%rbp), %ecx
movl %ecx, (%rax)
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_opt_free
void hts_opt_free(hts_opt *opts) {
    hts_opt *last = NULL;
    while (opts) {
        opts = (last=opts)->next;
        free(last->arg);
        free(last);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c8f2
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x45a0
movq -0x10(%rbp), %rdi
callq 0x45a0
jmp 0x1c8c4
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_parse_opt_list
int hts_parse_opt_list(htsFormat *fmt, const char *str) {
    while (str && *str) {
        const char *str_start;
        int len;
        char arg[8001];

        while (*str && *str == ',')
            str++;

        for (str_start = str; *str && *str != ','; str++);
        len = str - str_start;

        // Produce a nul terminated copy of the option
        strncpy(arg, str_start, len < 8000 ? len : 8000);
        arg[len < 8000 ? len : 8000] = '\0';

        if (hts_opt_add((hts_opt **)&fmt->specific, arg) != 0)
            return -1;

        if (*str)
            str++;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f90, %rsp           # imm = 0x1F90
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1f71(%rbp)
je 0x1c935
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1f71(%rbp)
movb -0x1f71(%rbp), %al
testb $0x1, %al
jne 0x1c944
jmp 0x1caa3
jmp 0x1c946
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1f72(%rbp)
je 0x1c96d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
sete %al
movb %al, -0x1f72(%rbp)
movb -0x1f72(%rbp), %al
testb $0x1, %al
jne 0x1c979
jmp 0x1c987
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c946
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1f73(%rbp)
je 0x1c9b6
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
setne %al
movb %al, -0x1f73(%rbp)
movb -0x1f73(%rbp), %al
testb $0x1, %al
jne 0x1c9c2
jmp 0x1c9d2
jmp 0x1c9c4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c98f
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
leaq -0x1f70(%rbp), %rax
movq %rax, -0x1f88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x1f80(%rbp)
cmpl $0x1f40, -0x24(%rbp)    # imm = 0x1F40
jge 0x1ca0d
movl -0x24(%rbp), %eax
movl %eax, -0x1f8c(%rbp)
jmp 0x1ca1a
movl $0x1f40, %eax           # imm = 0x1F40
movl %eax, -0x1f8c(%rbp)
jmp 0x1ca1a
movq -0x1f80(%rbp), %rsi
movq -0x1f88(%rbp), %rdi
movl -0x1f8c(%rbp), %eax
movslq %eax, %rdx
callq 0x4240
cmpl $0x1f40, -0x24(%rbp)    # imm = 0x1F40
jge 0x1ca4a
movl -0x24(%rbp), %eax
movl %eax, -0x1f90(%rbp)
jmp 0x1ca57
movl $0x1f40, %eax           # imm = 0x1F40
movl %eax, -0x1f90(%rbp)
jmp 0x1ca57
movl -0x1f90(%rbp), %eax
cltq
movb $0x0, -0x1f70(%rbp,%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
leaq -0x1f70(%rbp), %rsi
callq 0x1b180
cmpl $0x0, %eax
je 0x1ca89
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1caaa
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1ca9e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c913
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1f90, %rsp           # imm = 0x1F90
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: scan_keyword
static const char *
scan_keyword(const char *str, char delim, char *buf, size_t buflen)
{
    size_t i = 0;
    while (*str && *str != delim) {
        if (i < buflen-1) buf[i++] = tolower_c(*str);
        str++;
    }

    buf[i] = '\0';
    return *str? str+1 : str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x1ce76
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1ce7f
jmp 0x1cec2
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1ceb4
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x19510
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1ce52
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1cee8
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1cef0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: format_category
static enum htsFormatCategory format_category(enum htsExactFormat fmt)
{
    switch (fmt) {
    case bam:
    case sam:
    case cram:
    case fastq_format:
    case fasta_format:
        return sequence_data;

    case vcf:
    case bcf:
        return variant_data;

    case bai:
    case crai:
    case csi:
    case fai_format:
    case fqi_format:
    case gzi:
    case tbi:
        return index_file;

    case bed:
    case d4_format:
        return region_list;

    case htsget:
    case hts_crypt4gh_format:
        return unknown_category;

    case unknown_format:
    case binary_format:
    case text_format:
    case empty_format:
    case format_maximum:
        break;
    }

    return unknown_category;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x3, %eax
jb 0x1d1f2
jmp 0x1d118
movl -0xc(%rbp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0x1d1c5
jmp 0x1d129
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x1d1d7
jmp 0x1d137
movl -0xc(%rbp), %eax
subl $0x6, %eax
je 0x1d1c5
jmp 0x1d145
movl -0xc(%rbp), %eax
subl $0x7, %eax
je 0x1d1d7
jmp 0x1d153
movl -0xc(%rbp), %eax
addl $-0x8, %eax
subl $0x2, %eax
jb 0x1d1ce
jmp 0x1d160
movl -0xc(%rbp), %eax
addl $-0xa, %eax
subl $0x3, %eax
jb 0x1d1d7
jmp 0x1d16d
movl -0xc(%rbp), %eax
subl $0xd, %eax
je 0x1d1e0
jmp 0x1d177
movl -0xc(%rbp), %eax
subl $0xe, %eax
je 0x1d1e9
jmp 0x1d181
movl -0xc(%rbp), %eax
subl $0xf, %eax
je 0x1d1f2
jmp 0x1d18b
movl -0xc(%rbp), %eax
addl $-0x10, %eax
subl $0x2, %eax
jb 0x1d1c5
jmp 0x1d198
movl -0xc(%rbp), %eax
addl $-0x12, %eax
subl $0x2, %eax
jb 0x1d1d7
jmp 0x1d1a5
movl -0xc(%rbp), %eax
subl $0x14, %eax
je 0x1d1e9
jmp 0x1d1af
movl -0xc(%rbp), %eax
subl $0x15, %eax
je 0x1d1e0
jmp 0x1d1b9
movl -0xc(%rbp), %eax
subl $0x7fff, %eax           # imm = 0x7FFF
je 0x1d1f2
jmp 0x1d1f4
movl $0x1, -0x4(%rbp)
jmp 0x1d1fb
movl $0x2, -0x4(%rbp)
jmp 0x1d1fb
movl $0x3, -0x4(%rbp)
jmp 0x1d1fb
movl $0x4, -0x4(%rbp)
jmp 0x1d1fb
movl $0x0, -0x4(%rbp)
jmp 0x1d1fb
jmp 0x1d1f4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_process_opts
static int hts_process_opts(htsFile *fp, const char *opts) {
    htsFormat fmt;

    fmt.specific = NULL;
    if (hts_parse_opt_list(&fmt, opts) != 0)
        return -1;

    if (hts_opt_apply(fp, fmt.specific) != 0) {
        hts_opt_free(fmt.specific);
        return -1;
    }

    hts_opt_free(fmt.specific);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1c900
cmpl $0x0, %eax
je 0x1d233
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d267
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1af20
cmpl $0x0, %eax
je 0x1d257
movq -0x20(%rbp), %rdi
callq 0x1c8b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d267
movq -0x20(%rbp), %rdi
callq 0x1c8b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/hts.c
// Function: hts_idx_close_otf_fp
static int hts_idx_close_otf_fp(hts_idx_t *idx)
{
    if (idx && idx->otf_fp) {
        int ret = 0;
        if (need_idx_ugly_delay_hack(idx)) {
            // BAI index - write out the bytes we deferred earlier
            ret = idx_write_uint64(idx->otf_fp, idx->n_no_coor) < 0;
        }
        ret |= bgzf_close(idx->otf_fp) < 0;
        idx->otf_fp = NULL;
        return ret == 0 ? 0 : -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1d54a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x1d54a
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28580
cmpl $0x0, %eax
je 0x1d505
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x28540
cmpq $0x0, %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x103d0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x98(%rax)
movl -0x14(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1d551
movl $0x0, -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/hts.c
// Function: hts_idx_destroy
void hts_idx_destroy(hts_idx_t *idx)
{
    khint_t k;
    int i;
    if (idx == 0) return;

    // For HTS_FMT_CRAI, idx actually points to a different type -- see sam.c
    if (idx->fmt == HTS_FMT_CRAI) {
        hts_cram_idx_t *cidx = (hts_cram_idx_t *) idx;
        cram_index_free(cidx->cram);
        free(cidx);
        return;
    }

    for (i = 0; i < idx->m; ++i) {
        bidx_t *bidx = idx->bidx[i];
        free(idx->lidx[i].offset);
        if (bidx == 0) continue;
        for (k = kh_begin(bidx); k != kh_end(bidx); ++k)
            if (kh_exist(bidx, k))
                free(kh_value(bidx, k).list);
        kh_destroy(bin, bidx);
    }
    free(idx->bidx); free(idx->lidx); free(idx->meta);
    free(idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1d578
jmp 0x1d69a
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x1d5a4
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6aff0
movq -0x18(%rbp), %rdi
callq 0x45a0
jmp 0x1d69a
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x1d66a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x45a0
cmpq $0x0, -0x20(%rbp)
jne 0x1d5f4
jmp 0x1d65c
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x1d653
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0xc(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x1d646
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x45a0
jmp 0x1d648
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1d5fb
movq -0x20(%rbp), %rdi
callq 0x202e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1d5ab
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rdi
callq 0x45a0
addq $0x20, %rsp
popq %rbp
retq