// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_decode.c
// Function: cram_next_slice
cram_slice *cram_next_slice(cram_fd *fd, cram_container **cp) {
    cram_container *c_curr;  // container being consumed via cram_get_seq()
    cram_slice *s_curr = NULL;

    // Populate the first container if unknown.
    if (!(c_curr = fd->ctr)) {
        if (!(c_curr = cram_first_slice(fd)))
            return NULL;
    }

    // Discard previous slice
    if ((s_curr = c_curr->slice)) {
        c_curr->slice = NULL;
        cram_free_slice(s_curr);
        s_curr = NULL;
    }

    // If we've consumed all slices in this container, also discard
    // the container too.
    if (c_curr->curr_slice == c_curr->max_slice) {
        if (fd->ctr == c_curr)
            fd->ctr = NULL;
        if (fd->ctr_mt == c_curr)
            fd->ctr_mt = NULL;
        cram_free_container(c_curr);
        c_curr = NULL;
    }

    if (!fd->ctr_mt)
        fd->ctr_mt = c_curr;

    // Fetch the next slice (and the container if necessary).
    //
    // If single threaded this loop bails out as soon as it finds
    // a slice in range.  In this case c_next and c_curr end up being
    // the same thing.
    //
    // If multi-threaded, we loop until we have filled out
    // thread pool input queue.  Here c_next and c_curr *may* differ, as
    // can fd->ctr and fd->ctr_mt.
    for (;;) {
        cram_container *c_next = fd->ctr_mt;
        cram_slice *s_next = NULL;

        // Next slice; either from the last job we failed to push
        // to the input queue or via more I/O.
        if (fd->job_pending) {
            cram_decode_job *j = (cram_decode_job *)fd->job_pending;
            c_next = j->c;
            s_next = j->s;
            free(fd->job_pending);
            fd->job_pending = NULL;
        } else if (!fd->ooc) {
        empty_container:
            if (!c_next || c_next->curr_slice_mt == c_next->max_slice) {
                // new container
                for(;;) {
                    if (!(c_next = cram_read_container(fd))) {
                        if (fd->pool) {
                            fd->ooc = 1;
                            break;
                        }

                        return NULL;
                    }
                    c_next->curr_slice_mt = c_next->curr_slice;

                    if (c_next->length != 0)
                        break;

                    cram_free_container(c_next);
                }
                if (fd->ooc)
                    break;

//                printf("%p %d:%ld-%ld vs %d:%ld-%ld\n", fd,
//                       c_next->ref_seq_id, c_next->ref_seq_start, c_next->ref_seq_start+c_next->ref_seq_span-1,
//                       fd->range.refid, fd->range.start, fd->range.end);

                /* Skip containers not yet spanning our range */
                if (fd->range.refid != -2 && c_next->ref_seq_id != -2) {
                    // ref_id beyond end of range; bail out
                    if (c_next->ref_seq_id != fd->range.refid) {
                        cram_free_container(c_next);
                        fd->ctr_mt = NULL;
                        fd->ooc = 1;
                        break;
                    }

                    // position beyond end of range; bail out
                    if (fd->range.refid != -1 &&
                        c_next->ref_seq_start > fd->range.end) {
                        cram_free_container(c_next);
                        fd->ctr_mt = NULL;
                        fd->ooc = 1;
                        break;
                    }

                    // before start of range; skip to next container
                    if (fd->range.refid != -1 &&
                        c_next->ref_seq_start + c_next->ref_seq_span-1 <
                        fd->range.start) {
                        c_next->curr_slice_mt = c_next->max_slice;
                        cram_seek(fd, c_next->length, SEEK_CUR);
                        cram_free_container(c_next);
                        c_next = NULL;
                        continue;
                    }
                }

                // Container is valid range, so remember it for restarting
                // this function.
                fd->ctr_mt = c_next;

                if (!(c_next->comp_hdr_block = cram_read_block(fd)))
                    return NULL;
                if (c_next->comp_hdr_block->content_type != COMPRESSION_HEADER)
                    return NULL;

                c_next->comp_hdr =
                    cram_decode_compression_header(fd, c_next->comp_hdr_block);
                if (!c_next->comp_hdr)
                    return NULL;

                if (!c_next->comp_hdr->AP_delta &&
                    sam_hrecs_sort_order(fd->header->hrecs) != ORDER_COORD) {
                    pthread_mutex_lock(&fd->ref_lock);
                    fd->unsorted = 1;
                    pthread_mutex_unlock(&fd->ref_lock);
                }
            }

            if (c_next->num_records == 0) {
                if (fd->ctr == c_next)
                    fd->ctr = NULL;
                if (c_curr == c_next)
                    c_curr = NULL;
                if (fd->ctr_mt == c_next)
                    fd->ctr_mt = NULL;
                cram_free_container(c_next);
                c_next = NULL;
                goto empty_container;
            }

            if (!(s_next = c_next->slice = cram_read_slice(fd)))
                return NULL;

            s_next->slice_num = ++c_next->curr_slice_mt;
            s_next->curr_rec = 0;
            s_next->max_rec = s_next->hdr->num_records;

            s_next->last_apos = s_next->hdr->ref_seq_start;

            // We know the container overlaps our range, but with multi-slice
            // containers we may have slices that do not.  Skip these also.
            if (fd->range.refid != -2 && s_next->hdr->ref_seq_id != -2) {
                // ref_id beyond end of range; bail out
                if (s_next->hdr->ref_seq_id != fd->range.refid) {
                    fd->ooc = 1;
                    cram_free_slice(s_next);
                    c_next->slice = s_next = NULL;
                    break;
                }

                // position beyond end of range; bail out
                if (fd->range.refid != -1 &&
                    s_next->hdr->ref_seq_start > fd->range.end) {
                    fd->ooc = 1;
                    cram_free_slice(s_next);
                    c_next->slice = s_next = NULL;
                    break;
                }

                // before start of range; skip to next slice
                if (fd->range.refid != -1 &&
                    s_next->hdr->ref_seq_start + s_next->hdr->ref_seq_span-1 <
                    fd->range.start) {
                    cram_free_slice(s_next);
                    c_next->slice = s_next = NULL;
                    continue;
                }
            }
        } // end: if (!fd->ooc)

        if (!c_next || !s_next)
            break;

        // Decode the slice, either right now (non-threaded) or by pushing
        // it to the a decode queue (threaded).
        if (cram_decode_slice_mt(fd, c_next, s_next, fd->header) != 0) {
            hts_log_error("Failure to decode slice");
            cram_free_slice(s_next);
            c_next->slice = NULL;
            return NULL;
        }

        // No thread pool, so don't loop again
        if (!fd->pool) {
            c_curr = c_next;
            s_curr = s_next;
            break;
        }

        // With thread pool, but we have a job pending so our decode queue
        // is full.
        if (fd->job_pending)
            break;

        // Otherwise we're threaded with room in the decode input queue, so
        // keep reading slices for decode.
        // Push it a bit far, to qsize in queue rather than pending arrival,
        // as cram tends to be a bit bursty in decode timings.
        if (hts_tpool_process_len(fd->rqueue) >
            hts_tpool_process_qsize(fd->rqueue))
            break;
    } // end of for(;;)


    // When not threaded we've already have c_curr and s_curr.
    // Otherwise we need get them by pulling off the decode output queue.
    if (fd->pool) {
        hts_tpool_result *res;
        cram_decode_job *j;

        if (fd->ooc && hts_tpool_process_empty(fd->rqueue)) {
            fd->eof = 1;
            return NULL;
        }

        res = hts_tpool_next_result_wait(fd->rqueue);

        if (!res || !hts_tpool_result_data(res)) {
            hts_log_error("Call to hts_tpool_next_result failed");
            return NULL;
        }

        j = (cram_decode_job *)hts_tpool_result_data(res);
        c_curr = j->c;
        s_curr = j->s;

        if (j->exit_code != 0) {
            hts_log_error("Slice decode failure");
            fd->eof = 0;
            hts_tpool_delete_result(res, 1);
            return NULL;
        }

        hts_tpool_delete_result(res, 1);
    }

    *cp = c_curr;

    // Update current slice being processed (as opposed to current
    // slice in the multi-threaded reahead.
    fd->ctr = c_curr;
    if (c_curr) {
        c_curr->slice = s_curr;
        if (s_curr)
            c_curr->curr_slice = s_curr->slice_num;
    }
    if (s_curr)
        s_curr->curr_rec = 0;
    else
        fd->eof = 1;

    return s_curr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5881c
movq -0x10(%rbp), %rdi
callq 0x59020
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5881a
movq $0x0, -0x8(%rbp)
jmp 0x59016
jmp 0x5881c
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x58851
movq -0x20(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x28(%rbp), %rdi
callq 0x74f20
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x5c(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x58(%rcx), %eax
jne 0x588a6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x5887b
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x58895
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rdi
callq 0x74a70
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x588bd
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x588bf
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8970(%rax)
je 0x5892c
movq -0x10(%rbp), %rax
movq 0x8970(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8970(%rax), %rdi
callq 0x45a0
movq -0x10(%rbp), %rax
movq $0x0, 0x8970(%rax)
jmp 0x58daf
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8978(%rax)
jne 0x58dad
jmp 0x5893f
cmpq $0x0, -0x30(%rbp)
je 0x5895a
movq -0x30(%rbp), %rax
movl 0x60(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x58(%rcx), %eax
jne 0x58bb0
jmp 0x5895c
movq -0x10(%rbp), %rdi
callq 0x75260
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x5899a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88b8(%rax)
je 0x5898d
movq -0x10(%rbp), %rax
movl $0x1, 0x8978(%rax)
jmp 0x589be
movq $0x0, -0x8(%rbp)
jmp 0x59016
movq -0x30(%rbp), %rax
movl 0x5c(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x589b3
jmp 0x589be
movq -0x30(%rbp), %rdi
callq 0x74a70
jmp 0x5895c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8978(%rax)
je 0x589d0
jmp 0x58e82
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x258(%rax)
je 0x58add
movq -0x30(%rbp), %rax
cmpl $-0x2, 0x4(%rax)
je 0x58add
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x258(%rcx), %eax
je 0x58a2a
movq -0x30(%rbp), %rdi
callq 0x74a70
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8978(%rax)
jmp 0x58e82
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x258(%rax)
je 0x58a74
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x268(%rcx), %rax
jle 0x58a74
movq -0x30(%rbp), %rdi
callq 0x74a70
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8978(%rax)
jmp 0x58e82
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x258(%rax)
je 0x58adb
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
addq 0x10(%rcx), %rax
subq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x260(%rcx), %rax
jge 0x58adb
movq -0x30(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq (%rax), %rsi
movl $0x1, %edx
callq 0x79840
movq -0x30(%rbp), %rdi
callq 0x74a70
movq $0x0, -0x30(%rbp)
jmp 0x588bf
jmp 0x58add
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x6eec0
movq -0x30(%rbp), %rcx
movq %rax, 0x50(%rcx)
cmpq $0x0, %rax
jne 0x58b0d
movq $0x0, -0x8(%rbp)
jmp 0x59016
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x1, 0x8(%rax)
je 0x58b28
movq $0x0, -0x8(%rbp)
jmp 0x59016
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x4f0d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x58b5c
movq $0x0, -0x8(%rbp)
jmp 0x59016
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x58bae
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rdi
callq 0xde810
cmpl $0x2, %eax
je 0x58bae
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4730
movq -0x10(%rbp), %rax
movl $0x1, 0x88a4(%rax)
movq -0x10(%rbp), %rdi
addq $0x88f0, %rdi           # imm = 0x88F0
callq 0x4330
jmp 0x58bb0
movq -0x30(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x58c16
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x30(%rbp), %rax
jne 0x58bd4
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x58be6
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x30(%rbp), %rax
jne 0x58c00
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x30(%rbp), %rdi
callq 0x74a70
movq $0x0, -0x30(%rbp)
jmp 0x5893f
movq -0x10(%rbp), %rdi
callq 0x771c0
movq -0x30(%rbp), %rcx
movq %rax, 0x90(%rcx)
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x58c41
movq $0x0, -0x8(%rbp)
jmp 0x59016
movq -0x30(%rbp), %rax
movl 0x60(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x60(%rax)
movq -0x38(%rbp), %rax
movl %ecx, 0xe8(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0xe4(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x18(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xe0(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x258(%rax)
je 0x58dab
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpl $-0x2, 0x4(%rax)
je 0x58dab
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x258(%rcx), %eax
je 0x58cf8
movq -0x10(%rbp), %rax
movl $0x1, 0x8978(%rax)
movq -0x38(%rbp), %rdi
callq 0x74f20
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, 0x90(%rax)
jmp 0x58e82
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x258(%rax)
je 0x58d50
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x268(%rcx), %rax
jle 0x58d50
movq -0x10(%rbp), %rax
movl $0x1, 0x8978(%rax)
movq -0x38(%rbp), %rdi
callq 0x74f20
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, 0x90(%rax)
jmp 0x58e82
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x258(%rax)
je 0x58da9
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
addq 0x10(%rcx), %rax
subq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x260(%rcx), %rax
jge 0x58da9
movq -0x38(%rbp), %rdi
callq 0x74f20
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, 0x90(%rax)
jmp 0x588bf
jmp 0x58dab
jmp 0x58dad
jmp 0x58daf
cmpq $0x0, -0x30(%rbp)
je 0x58dbd
cmpq $0x0, -0x38(%rbp)
jne 0x58dc2
jmp 0x58e82
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
callq 0x57f00
cmpl $0x0, %eax
je 0x58e1f
movl $0x1, %edi
leaq 0x9ac1e(%rip), %rsi     # 0xf3a0a
leaq 0x9ac27(%rip), %rdx     # 0xf3a1a
movb $0x0, %al
callq 0x1b030
movq -0x38(%rbp), %rdi
callq 0x74f20
movq -0x30(%rbp), %rax
movq $0x0, 0x90(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x59016
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88b8(%rax)
jne 0x58e3f
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x58e82
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8970(%rax)
je 0x58e4f
jmp 0x58e82
movq -0x10(%rbp), %rax
movq 0x88c0(%rax), %rdi
callq 0x4d2a0
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
movq 0x88c0(%rax), %rdi
callq 0x4e950
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jle 0x58e7d
jmp 0x58e82
jmp 0x588bf
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88b8(%rax)
je 0x58fa2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8978(%rax)
je 0x58ed1
movq -0x10(%rbp), %rax
movq 0x88c0(%rax), %rdi
callq 0x4d190
cmpl $0x0, %eax
je 0x58ed1
movq -0x10(%rbp), %rax
movl $0x1, 0x8890(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x59016
movq -0x10(%rbp), %rax
movq 0x88c0(%rax), %rdi
callq 0x4cf90
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x58efb
movq -0x48(%rbp), %rdi
callq 0x4d460
cmpq $0x0, %rax
jne 0x58f22
movl $0x1, %edi
leaq 0x9ab03(%rip), %rsi     # 0xf3a0a
leaq 0x9ab24(%rip), %rdx     # 0xf3a32
movb $0x0, %al
callq 0x1b030
movq $0x0, -0x8(%rbp)
jmp 0x59016
movq -0x48(%rbp), %rdi
callq 0x4d460
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x58f94
movl $0x1, %edi
leaq 0x9aaad(%rip), %rsi     # 0xf3a0a
leaq 0x9aaf3(%rip), %rdx     # 0xf3a57
movb $0x0, %al
callq 0x1b030
movq -0x10(%rbp), %rax
movl $0x0, 0x8890(%rax)
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x4d410
movq $0x0, -0x8(%rbp)
jmp 0x59016
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x4d410
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x58fe9
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x90(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x58fe7
movq -0x28(%rbp), %rax
movl 0xe8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x5c(%rax)
jmp 0x58fe9
cmpq $0x0, -0x28(%rbp)
je 0x59000
movq -0x28(%rbp), %rax
movl $0x0, 0xe4(%rax)
jmp 0x5900e
movq -0x10(%rbp), %rax
movl $0x1, 0x8890(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq