// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/bgzf.c
// Function: bgzf_read_block
int bgzf_read_block(BGZF *fp)
{
    hts_tpool_result *r;

    if (fp->errcode) return -1;

    if (fp->mt) {
    again:
        if (fp->mt->hit_eof) {
            // Further reading at EOF will always return 0
            fp->block_length = 0;
            return 0;
        }
        r = hts_tpool_next_result_wait(fp->mt->out_queue);
        bgzf_job *j = r ? (bgzf_job *)hts_tpool_result_data(r) : NULL;

        if (!j || j->errcode == BGZF_ERR_MT) {
            if (!fp->mt->free_block) {
                fp->uncompressed_block = malloc(2 * BGZF_MAX_BLOCK_SIZE);
                if (fp->uncompressed_block == NULL) return -1;
                fp->compressed_block = (char *)fp->uncompressed_block + BGZF_MAX_BLOCK_SIZE;
            } // else it's already allocated with malloc, maybe even in-use.
            if (mt_destroy(fp->mt) < 0) {
                fp->errcode = BGZF_ERR_IO;
            }
            fp->mt = NULL;
            hts_tpool_delete_result(r, 0);
            if (fp->errcode) {
                return -1;
            }
            goto single_threaded;
        }

        if (j->errcode) {
            fp->errcode = j->errcode;
            hts_log_error("BGZF decode jobs returned error %d "
                          "for block offset %"PRId64,
                          j->errcode, j->block_address);
            hts_tpool_delete_result(r, 0);
            return -1;
        }

        if (j->hit_eof) {
            if (!fp->last_block_eof && !fp->no_eof_block) {
                fp->no_eof_block = 1;
                hts_log_warning("EOF marker is absent. The input may be truncated");
            }
            fp->mt->hit_eof = 1;
        }

        // Zero length blocks in the middle of a file are (wrongly)
        // considered as EOF by many callers.  We work around this by
        // trying again to see if we hit a genuine EOF.
        if (!j->hit_eof && j->uncomp_len == 0) {
            fp->last_block_eof = 1;
            hts_tpool_delete_result(r, 0);
            goto again;
        }

        // block_length=0 and block_offset set by bgzf_seek.
        if (fp->block_length != 0) fp->block_offset = 0;
        if (!j->hit_eof) fp->block_address = j->block_address;
        fp->block_clength = j->comp_len;
        fp->block_length = j->uncomp_len;
        // bgzf_read() can change fp->block_length
        fp->last_block_eof = (fp->block_length == 0);

        if ( j->uncomp_len && j->fp->idx_build_otf )
        {
            bgzf_index_add_block(j->fp);
            j->fp->idx->ublock_addr += j->uncomp_len;
        }

        // Steal the data block as it's quicker than a memcpy.
        // We just need to make sure we delay the pool free.
        if (fp->mt->curr_job) {
            pthread_mutex_lock(&fp->mt->job_pool_m);
            pool_free(fp->mt->job_pool, fp->mt->curr_job);
            pthread_mutex_unlock(&fp->mt->job_pool_m);
        }
        fp->uncompressed_block = j->uncomp_data;
        fp->mt->curr_job = j;
        if (fp->mt->free_block) {
            free(fp->mt->free_block); // clear up last non-mt block
            fp->mt->free_block = NULL;
        }

        hts_tpool_delete_result(r, 0);
        return 0;
    }

    uint8_t header[BLOCK_HEADER_LENGTH], *compressed_block;
    int count, size, block_length, remaining;

 single_threaded:
    size = 0;

    int64_t block_address;
    block_address = bgzf_htell(fp);

    // Reading an uncompressed file
    if ( !fp->is_compressed )
    {
        count = hread(fp->fp, fp->uncompressed_block, BGZF_MAX_BLOCK_SIZE);
        if (count < 0)  // Error
        {
            hts_log_error("Failed to read uncompressed data "
                          "at offset %"PRId64"%s%s",
                          block_address, errno ? ": " : "", strerror(errno));
            fp->errcode |= BGZF_ERR_IO;
            return -1;
        }
        else if (count == 0)  // EOF
        {
            fp->block_length = 0;
            return 0;
        }
        if (fp->block_length != 0) fp->block_offset = 0;
        fp->block_address = block_address;
        fp->block_length = count;
        return 0;
    }

    // Reading compressed file
    if ( fp->is_gzip && fp->gz_stream ) // is this is an initialized gzip stream?
    {
        count = inflate_gzip_block(fp);
        if ( count<0 )
        {
            hts_log_error("Reading GZIP stream failed at offset %"PRId64,
                          block_address);
            fp->errcode |= BGZF_ERR_ZLIB;
            return -1;
        }
        fp->block_length = count;
        fp->block_address = block_address;
        return 0;
    }
    if (fp->cache_size && load_block_from_cache(fp, block_address)) return 0;

    // loop to skip empty bgzf blocks
    while (1)
    {
        count = hread(fp->fp, header, sizeof(header));
        if (count == 0) { // no data read
            if (!fp->last_block_eof && !fp->no_eof_block && !fp->is_gzip) {
                fp->no_eof_block = 1;
                hts_log_warning("EOF marker is absent. The input may be truncated");
            }
            fp->block_length = 0;
            return 0;
        }
        int ret = 0;
        if ( count != sizeof(header) || (ret=check_header(header))==-2 )
        {
            fp->errcode |= BGZF_ERR_HEADER;
            hts_log_error("%s BGZF header at offset %"PRId64,
                          ret ? "Invalid" : "Failed to read",
                          block_address);
            return -1;
        }
        if ( ret==-1 )
        {
            // GZIP, not BGZF
            uint8_t *cblock = (uint8_t*)fp->compressed_block;
            memcpy(cblock, header, sizeof(header));
            count = hread(fp->fp, cblock+sizeof(header), BGZF_BLOCK_SIZE - sizeof(header)) + sizeof(header);

            fp->is_gzip = 1;
            fp->gz_stream = (z_stream*) calloc(1,sizeof(z_stream));
            // Set up zlib, using a window size of 15, and its built-in GZIP header processing (+16).
            int ret = inflateInit2(fp->gz_stream, 15 + 16);
            if (ret != Z_OK)
            {
                hts_log_error("Call to inflateInit2 failed: %s", bgzf_zerr(ret, fp->gz_stream));
                fp->errcode |= BGZF_ERR_ZLIB;
                return -1;
            }
            fp->gz_stream->avail_in = count;
            fp->gz_stream->next_in  = cblock;
            count = inflate_gzip_block(fp);
            if ( count<0 )
            {
                hts_log_error("Reading GZIP stream failed at offset %"PRId64,
                              block_address);
                fp->errcode |= BGZF_ERR_ZLIB;
                return -1;
            }
            fp->block_length = count;
            fp->block_address = block_address;
            if ( fp->idx_build_otf ) return -1; // cannot build index for gzip
            return 0;
        }
        size = count;
        block_length = unpackInt16((uint8_t*)&header[16]) + 1; // +1 because when writing this number, we used "-1"
        if (block_length < BLOCK_HEADER_LENGTH)
        {
            hts_log_error("Invalid BGZF block length at offset %"PRId64,
                          block_address);
            fp->errcode |= BGZF_ERR_HEADER;
            return -1;
        }
        compressed_block = (uint8_t*)fp->compressed_block;
        memcpy(compressed_block, header, BLOCK_HEADER_LENGTH);
        remaining = block_length - BLOCK_HEADER_LENGTH;
        count = hread(fp->fp, &compressed_block[BLOCK_HEADER_LENGTH], remaining);
        if (count != remaining) {
            hts_log_error("Failed to read BGZF block data at offset %"PRId64
                          " expected %d bytes; hread returned %d",
                          block_address, remaining, count);
            fp->errcode |= BGZF_ERR_IO;
            return -1;
        }
        size += count;
        if ((count = inflate_block(fp, block_length)) < 0) {
            hts_log_debug("Inflate block operation failed for "
                          "block at offset %"PRId64": %s",
                          block_address, bgzf_zerr(count, NULL));
            fp->errcode |= BGZF_ERR_ZLIB;
            return -1;
        }
        fp->last_block_eof = (count == 0);
        if ( count ) break;     // otherwise an empty bgzf block
        block_address = bgzf_htell(fp); // update for new block start
    }
    if (fp->block_length != 0) fp->block_offset = 0; // Do not reset offset if this read follows a seek.
    fp->block_address = block_address;
    fp->block_length = count;
    if ( fp->idx_build_otf )
    {
        bgzf_index_add_block(fp);
        fp->idx->ublock_addr += count;
    }
    cache_block(fp, size);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpw $0x0, (%rdi)
jne 0xae9a
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0xafc5
movq 0x48(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0xaeab
movl $0x0, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8cb3e(%rip), %r12     # 0x979f0
leaq 0x8cb7f(%rip), %r13     # 0x97a38
movq 0x20(%rax), %rdi
callq 0x37249
movq %rax, %r14
testq %rax, %rax
je 0xaed7
movq %r14, %rdi
callq 0x37576
movq %rax, %r15
jmp 0xaeda
xorl %r15d, %r15d
testq %r15, %r15
je 0xaf6c
movl 0x20018(%r15), %eax
testl %eax, %eax
jne 0xaf63
cmpl $0x0, 0x20028(%r15)
je 0xaf25
movl (%rbx), %eax
testl $0x20040000, %eax       # imm = 0x20040000
jne 0xaf1a
orl $0x40000, %eax          # imm = 0x40000
movl %eax, (%rbx)
movl $0x3, %edi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x14378
movq 0x48(%rbx), %rax
movl $0x1, 0x68(%rax)
movl 0x20028(%r15), %eax
testl %eax, %eax
jne 0xb451
cmpq $0x0, 0x20010(%r15)
jne 0xb451
orb $0x20, 0x3(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x37551
movq 0x48(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0xaeb9
jmp 0xae91
cmpl $0x10, %eax
jne 0xb5e0
movq 0x48(%rbx), %r15
cmpq $0x0, 0x60(%r15)
jne 0xaf98
movl $0x20000, %edi          # imm = 0x20000
callq 0x4680
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0xae9a
addq $0x10000, %rax          # imm = 0x10000
movq %rax, 0x30(%rbx)
movq %r15, %rdi
callq 0xb672
testl %eax, %eax
jns 0xafa9
movw $0x4, (%rbx)
movq $0x0, 0x48(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x37551
cmpw $0x0, (%rbx)
jne 0xae9a
movq %rbx, %rdi
callq 0xb812
movq %rax, %r13
movl (%rbx), %eax
btl $0x1e, %eax
jb 0xb066
movq %r13, (%rsp)
movq 0x28(%rbx), %r15
movq 0x40(%rbx), %r12
movq 0x8(%r12), %rsi
movq 0x10(%r12), %r13
subq %rsi, %r13
movl $0x10000, %r14d         # imm = 0x10000
cmpq %r14, %r13
cmovbq %r13, %r14
movq %r15, %rdi
movq %r14, %rdx
callq 0x43c0
addq %r14, 0x8(%r12)
cmpq $0xffff, %r13           # imm = 0xFFFF
ja 0xb039
testb $0x2, 0x30(%r12)
je 0xb039
movl $0x10000, %edx          # imm = 0x10000
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0xf2cd
movq %rax, %r14
movq (%rsp), %r15
testl %r14d, %r14d
js 0xb525
je 0xae91
cmpl $0x0, 0x8(%rbx)
je 0xb059
movl $0x0, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movl %r14d, 0x8(%rbx)
jmp 0xae98
testl %eax, %eax
js 0xb570
cmpl $0x0, 0x4(%rbx)
je 0xb089
movq %rbx, %rdi
movq %r13, %rsi
callq 0xbafc
xorl %ebp, %ebp
testl %eax, %eax
jne 0xae9a
movl $0x0, 0x8(%rsp)
movq 0x40(%rbx), %r14
movq 0x8(%r14), %rsi
movq 0x10(%r14), %r15
subq %rsi, %r15
cmpq $0x12, %r15
movl $0x12, %r12d
cmovbq %r15, %r12
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
callq 0x43c0
addq %r12, 0x8(%r14)
cmpq $0x11, %r15
ja 0xb0e4
testb $0x2, 0x30(%r14)
je 0xb0e4
movl $0x12, %edx
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
movq %r12, %rcx
callq 0xf2cd
movq %rax, %r12
testl %r12d, %r12d
je 0xb61a
leaq 0x8c9f6(%rip), %rcx     # 0x97aea
cmpl $0x12, %r12d
jne 0xb119
leaq 0x10(%rsp), %rdi
callq 0xbc0e
cmpl $-0x1, %eax
je 0xb152
leaq 0x8c9d2(%rip), %rcx     # 0x97ae2
cmpl $-0x2, %eax
jne 0xb243
orb $0x2, (%rbx)
movl $0x1, %r14d
movl $0x1, %edi
leaq 0x8c8c2(%rip), %rsi     # 0x979f0
leaq 0x8c990(%rip), %rdx     # 0x97ac5
movq %r13, %r8
xorl %eax, %eax
callq 0x14378
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %r14d, %r14d
je 0xb091
jmp 0xb597
movq %r13, (%rsp)
movq 0x30(%rbx), %r13
movzwl 0x20(%rsp), %eax
movw %ax, 0x10(%r13)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r13)
movq 0x40(%rbx), %r14
leaq 0x12(%r13), %r15
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rbp
subq %rsi, %rbp
movl $0xfeee, %eax           # imm = 0xFEEE
cmpq %rax, %rbp
movl $0xfeee, %r12d          # imm = 0xFEEE
cmovbq %rbp, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x43c0
addq %r12, 0x8(%r14)
cmpq $0xfeed, %rbp           # imm = 0xFEED
ja 0xb1c8
testb $0x2, 0x30(%r14)
je 0xb1c8
movl $0xfeee, %edx           # imm = 0xFEEE
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0xf2cd
movq %rax, %r12
addl $0x12, %r12d
orb $-0x80, 0x3(%rbx)
movl $0x1, %edi
movl $0x70, %esi
callq 0x4300
movq %rax, 0x60(%rbx)
movq %rax, %rdi
movl $0x1f, %esi
leaq 0x8c78e(%rip), %rdx     # 0x97980
movl $0x70, %ecx
callq 0x43e0
movq 0x60(%rbx), %rsi
testl %eax, %eax
je 0xb2f6
movl %eax, %edi
callq 0xadd0
movl $0x1, %r14d
movl $0x1, %edi
leaq 0x8c7cf(%rip), %rsi     # 0x979f0
leaq 0x8c8d1(%rip), %rdx     # 0x97af9
movq %rax, %rcx
xorl %eax, %eax
callq 0x14378
orb $0x1, (%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq (%rsp), %r13
jmp 0xb144
movzwl 0x20(%rsp), %ecx
cmpl $0x10, %ecx
ja 0xb282
movl $0x1, %r14d
movl $0x1, %edi
leaq 0x8c791(%rip), %rsi     # 0x979f0
leaq 0x8c8b3(%rip), %rdx     # 0x97b19
movq %r13, %rcx
xorl %eax, %eax
callq 0x14378
orb $0x2, (%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %r12d, 0x8(%rsp)
jmp 0xb144
movq %r13, (%rsp)
movq 0x30(%rbx), %r14
movzwl 0x20(%rsp), %eax
movw %ax, 0x10(%r14)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r14)
movq %rcx, 0x28(%rsp)
leal -0x11(%rcx), %r13d
movq %r13, 0x30(%rsp)
movq 0x40(%rbx), %rcx
movq %rcx, 0x8(%rsp)
addq $0x12, %r14
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %r15
subq %rsi, %r15
cmpq %r13, %r15
cmovbq %r15, %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0x43c0
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %r8
movq %r13, %rcx
addq %r13, 0x8(%rdi)
cmpq %r8, %r15
jae 0xb2f1
testb $0x2, 0x30(%rdi)
jne 0xb35e
movq %rcx, %r15
jmp 0xb372
movl %r12d, 0x8(%rsi)
movq %r13, (%rsi)
movq %rbx, %rdi
callq 0xb8c5
movl %eax, %r12d
testl %eax, %eax
js 0xb32f
movl %r12d, 0x8(%rbx)
movq (%rsp), %r13
movq %r13, 0x18(%rbx)
xorl %eax, %eax
cmpl 0x58(%rbx), %eax
movl $0x0, %ebp
sbbl %ebp, %ebp
movl $0x1, %r14d
jmp 0xb144
movl $0x1, %r14d
movl $0x1, %edi
leaq 0x8c6af(%rip), %rsi     # 0x979f0
leaq 0x8c754(%rip), %rdx     # 0x97a9c
movq (%rsp), %r13
movq %r13, %rcx
xorl %eax, %eax
callq 0x14378
orb $0x1, (%rbx)
jmp 0xb13f
movq %r14, %rsi
movq %r8, %rdx
movq %r8, %r14
callq 0xf2cd
movq %r14, %r8
movq %rax, %r15
cmpl %r15d, %r8d
movq (%rsp), %r13
jne 0xb3d4
movq 0x28(%rsp), %rsi
incl %esi
addl %r12d, %r15d
movq %rbx, %rdi
callq 0xbc4f
movl %eax, %r12d
testl %eax, %eax
js 0xb40f
sete %al
movzbl %al, %eax
shll $0x1d, %eax
movl (%rbx), %ecx
movl $0xdfffffff, %edx       # imm = 0xDFFFFFFF
andl %edx, %ecx
orl %eax, %ecx
movl %ecx, (%rbx)
movl $0x5, %r14d
testl %r12d, %r12d
jne 0xb447
movq %rbx, %rdi
callq 0xb812
movq %rax, %r13
xorl %r12d, %r12d
movl %r15d, 0x8(%rsp)
xorl %r14d, %r14d
jmp 0xb144
movl $0x1, %r14d
movl $0x1, %edi
leaq 0x8c60a(%rip), %rsi     # 0x979f0
leaq 0x8c754(%rip), %rdx     # 0x97b41
movq %r13, %rcx
movl %r15d, %r9d
xorl %eax, %eax
callq 0x14378
orb $0x4, (%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %r12d, 0x8(%rsp)
movl %r15d, %r12d
jmp 0xb144
movl %r12d, %edi
xorl %esi, %esi
callq 0xadd0
movl $0x5, %edi
leaq 0x8c5cb(%rip), %rsi     # 0x979f0
leaq 0x8c767(%rip), %rdx     # 0x97b93
movq %r13, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x14378
orb $0x1, (%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x1, %r14d
movl %r15d, 0x8(%rsp)
jmp 0xb144
cmpl $0x0, 0x8(%rbx)
je 0xb45e
movl $0x0, 0x10(%rbx)
testl %eax, %eax
jne 0xb46d
movq 0x20020(%r15), %rax
movq %rax, 0x18(%rbx)
movl 0x10008(%r15), %eax
movl %eax, 0xc(%rbx)
movl 0x20010(%r15), %eax
movl %eax, 0x8(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
shll $0x1d, %ecx
movl $0xdfffffff, %eax       # imm = 0xDFFFFFFF
andl (%rbx), %eax
orl %ecx, %eax
movl %eax, (%rbx)
cmpq $0x0, 0x20010(%r15)
je 0xb4c0
movq (%r15), %rdi
cmpl $0x0, 0x58(%rdi)
je 0xb4c0
callq 0xb782
movq 0x20010(%r15), %rax
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
addq %rax, 0x10(%rcx)
movq 0x48(%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0xb4f1
addq $0x30, %rdi
callq 0x4750
movq 0x48(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x5a8fd
movq 0x48(%rbx), %rdi
addq $0x30, %rdi
callq 0x4340
leaq 0x10010(%r15), %rax
movq %rax, 0x28(%rbx)
movq 0x48(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x60(%rax), %rdi
testq %rdi, %rdi
je 0xb51e
callq 0x45c0
movq 0x48(%rbx), %rax
movq $0x0, 0x60(%rax)
xorl %ebp, %ebp
jmp 0xb60b
callq 0x4050
movl (%rax), %edi
testl %edi, %edi
leaq 0x8d798(%rip), %rax     # 0x98ccd
leaq 0x8d93a(%rip), %r14     # 0x98e76
cmoveq %rax, %r14
callq 0x4150
leaq 0x8c4a4(%rip), %rsi     # 0x979f0
leaq 0x8c516(%rip), %rdx     # 0x97a69
movl $0x1, %edi
movq %r15, %rcx
movq %r14, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x14378
orb $0x4, (%rbx)
jmp 0xae9a
cmpq $0x0, 0x60(%rbx)
je 0xb06e
movq %rbx, %rdi
callq 0xb8c5
testl %eax, %eax
js 0xb64d
movl %eax, 0x8(%rbx)
movq %r13, 0x18(%rbx)
jmp 0xae98
cmpl $0x5, %r14d
jne 0xae9a
cmpl $0x0, 0x8(%rbx)
je 0xb5ae
movl $0x0, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movl %r12d, 0x8(%rbx)
cmpl $0x0, 0x58(%rbx)
je 0xb5cf
movq %rbx, %rdi
callq 0xb782
movslq %r12d, %rax
movq 0x50(%rbx), %rcx
addq %rax, 0x10(%rcx)
movq %rbx, %rdi
movl 0x8(%rsp), %esi
callq 0xbca8
jmp 0xae98
movw %ax, (%rbx)
movl 0x20018(%r15), %ecx
movq 0x20020(%r15), %r8
leaq 0x8c3f8(%rip), %rsi     # 0x979f0
leaq 0x8c401(%rip), %rdx     # 0x97a00
movl $0x1, %edi
xorl %eax, %eax
callq 0x14378
movq %r14, %rdi
xorl %esi, %esi
callq 0x37551
jmp 0xae9a
movl (%rbx), %eax
testl $0xa0040000, %eax       # imm = 0xA0040000
jne 0xae91
orl $0x40000, %eax          # imm = 0x40000
movl %eax, (%rbx)
leaq 0x8c3bb(%rip), %rsi     # 0x979f0
leaq 0x8c3fc(%rip), %rdx     # 0x97a38
movl $0x3, %edi
xorl %eax, %eax
callq 0x14378
jmp 0xae91
leaq 0x8c39c(%rip), %rsi     # 0x979f0
leaq 0x8c441(%rip), %rdx     # 0x97a9c
movl $0x1, %edi
movq %r13, %rcx
xorl %eax, %eax
callq 0x14378
orb $0x1, (%rbx)
jmp 0xae9a