LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_io.c
// Function: cram_free_compression_header
void cram_free_compression_header(cram_block_compression_hdr *hdr) {
    int i;

    if (hdr->landmark)
	free(hdr->landmark);

    if (hdr->preservation_map)
	kh_destroy(map, hdr->preservation_map);

    for (i = 0; i < CRAM_MAP_HASH; i++) {
	cram_map *m, *m2;
	for (m = hdr->rec_encoding_map[i]; m; m = m2) {
	    m2 = m->next;
	    if (m->codec)
		m->codec->free(m->codec);
	    free(m);
	}
    }

    for (i = 0; i < CRAM_MAP_HASH; i++) {
	cram_map *m, *m2;
	for (m = hdr->tag_encoding_map[i]; m; m = m2) {
	    m2 = m->next;
	    if (m->codec)
		m->codec->free(m->codec);
	    free(m);
	}
    }

    for (i = 0; i < DS_END; i++) {
	if (hdr->codecs[i])
	    hdr->codecs[i]->free(hdr->codecs[i]);
    }

    if (hdr->TL)
	free(hdr->TL);
    if (hdr->TD_blk)
	cram_free_block(hdr->TD_blk);
    if (hdr->TD_hash)
	kh_destroy(m_s2i, hdr->TD_hash);
    if (hdr->TD_keys)
	string_pool_destroy(hdr->TD_keys);

    free(hdr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x59701
callq 0x68a0
movq 0x78(%rbx), %r14
testq %r14, %r14
je 0x5972d
movq 0x18(%r14), %rdi
callq 0x68a0
movq 0x10(%r14), %rdi
callq 0x68a0
movq 0x20(%r14), %rdi
callq 0x68a0
movq %r14, %rdi
callq 0x68a0
xorl %r15d, %r15d
movq 0x80(%rbx,%r15,8), %r14
testq %r14, %r14
je 0x5975d
movq 0x10(%r14), %rdi
movq 0x18(%r14), %r12
testq %rdi, %rdi
je 0x5974d
callq *0x10(%rdi)
movq %r14, %rdi
callq 0x68a0
movq %r12, %r14
testq %r12, %r12
jne 0x5973d
incq %r15
cmpq $0x20, %r15
jne 0x59730
xorl %r15d, %r15d
movq 0x180(%rbx,%r15,8), %r14
testq %r14, %r14
je 0x59796
movq 0x10(%r14), %rdi
movq 0x18(%r14), %r12
testq %rdi, %rdi
je 0x59786
callq *0x10(%rdi)
movq %r14, %rdi
callq 0x68a0
movq %r12, %r14
testq %r12, %r12
jne 0x59776
incq %r15
cmpq $0x20, %r15
jne 0x59769
movl $0x50, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x597b1
callq *0x10(%rdi)
incq %r14
cmpq $0x7f, %r14
jne 0x597a5
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x597c8
callq 0x68a0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x597d6
callq 0x56a50
movq 0x68(%rbx), %r14
testq %r14, %r14
je 0x59802
movq 0x18(%r14), %rdi
callq 0x68a0
movq 0x10(%r14), %rdi
callq 0x68a0
movq 0x20(%r14), %rdi
callq 0x68a0
movq %r14, %rdi
callq 0x68a0
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x59810
callq 0x650c3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x68a0
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_io.c
// Function: cram_flush_container2
static int cram_flush_container2(cram_fd *fd, cram_container *c) {
    int i, j;

    if (c->curr_slice > 0 && !c->slices)
	return -1;

    //fprintf(stderr, "Writing container %d, sum %u\n", c->record_counter, sum);

    /* Write the container struct itself */
    if (0 != cram_write_container(fd, c))
	return -1;

    /* And the compression header */
    if (0 != cram_write_block(fd, c->comp_hdr_block))
	return -1;

    /* Followed by the slice blocks */
    for (i = 0; i < c->curr_slice; i++) {
	cram_slice *s = c->slices[i];

	if (0 != cram_write_block(fd, s->hdr_block))
	    return -1;

	for (j = 0; j < s->hdr->num_blocks; j++) {
	    if (0 != cram_write_block(fd, s->block[j]))
		return -1;
	}
    }

    return hflush(fd->fp) == 0 ? 0 : -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x0, 0x54(%rsi)
jle 0x5ae4a
cmpq $0x0, 0x78(%r15)
je 0x5aee0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a5ef
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x5aee5
movq 0x48(%r15), %rsi
movq %r14, %rdi
callq 0x56662
testl %eax, %eax
jne 0x5aee5
cmpl $0x0, 0x54(%r15)
jle 0x5aed0
xorl %r12d, %r12d
movq 0x78(%r15), %rax
movq (%rax,%r12,8), %r13
movq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0x56662
testl %eax, %eax
jne 0x5aee5
movq (%r13), %rax
cmpl $0x0, 0x20(%rax)
jle 0x5aec4
xorl %ebp, %ebp
movq 0x10(%r13), %rax
movq (%rax,%rbp,8), %rsi
movq %r14, %rdi
callq 0x56662
testl %eax, %eax
jne 0x5aee5
incq %rbp
movq (%r13), %rax
movslq 0x20(%rax), %rax
cmpq %rax, %rbp
jl 0x5aea0
incq %r12
movslq 0x54(%r15), %rax
cmpq %rax, %r12
jl 0x5ae7c
movq (%r14), %rdi
callq 0x6b16c
xorl %ebx, %ebx
negl %eax
sbbl %ebx, %ebx
jmp 0x5aee5
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_io.c
// Function: cram_flush_container_mt
int cram_flush_container_mt(cram_fd *fd, cram_container *c) {
    cram_job *j;

    if (!fd->pool)
	return cram_flush_container(fd, c);

    if (!(j = malloc(sizeof(*j))))
	return -1;
    j->fd = fd;
    j->c = c;
    
    t_pool_dispatch(fd->pool, fd->rqueue, cram_flush_thread, j);

    return cram_flush_result(fd);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8860(%rdi), %r15
testq %r15, %r15
je 0x5af68
movl $0x10, %edi
callq 0x69d0
testq %rax, %rax
je 0x5af78
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq 0x8868(%rbx), %rsi
leaq -0x5d(%rip), %rdx       # 0x5aef6
movq %r15, %rdi
movq %rax, %rcx
callq 0x65784
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5af83
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x5adf9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_io.c
// Function: cram_flush_result
static int cram_flush_result(cram_fd *fd) {
    int i, ret = 0;
    t_pool_result *r;

    while ((r = t_pool_next_result(fd->rqueue))) {
	cram_job *j = (cram_job *)r->data;
	cram_container *c;

	if (!j) {
	    t_pool_delete_result(r, 0);
	    return -1;
	}

	fd = j->fd;
	c = j->c;

	if (0 != cram_flush_container2(fd, c))
	    return -1;

	/* Free the container */
	for (i = 0; i < c->max_slice; i++) {
	    cram_free_slice(c->slices[i]);
	    c->slices[i] = NULL;
	}

	c->slice = NULL;
	c->curr_slice = 0;

	cram_free_container(c);

	ret |= hflush(fd->fp) == 0 ? 0 : -1;

	t_pool_delete_result(r, 1);
    }

    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8868(%rdi), %rdi
callq 0x65214
testq %rax, %rax
je 0x5b057
movq %rax, %r14
xorl %ebx, %ebx
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x5b05b
movq (%rax), %r15
movq 0x8(%rax), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x5ae28
testl %eax, %eax
jne 0x5b065
cmpl $0x0, 0x50(%r12)
jle 0x5b000
xorl %r13d, %r13d
movq 0x78(%r12), %rax
movq (%rax,%r13,8), %rdi
callq 0x59823
movq 0x78(%r12), %rax
movq $0x0, (%rax,%r13,8)
incq %r13
movslq 0x50(%r12), %rax
cmpq %rax, %r13
jl 0x5afd8
movq $0x0, 0x80(%r12)
movl $0x0, 0x54(%r12)
movq %r12, %rdi
callq 0x59605
movq (%r15), %rdi
callq 0x6b16c
negl %eax
movl $0x0, %eax
sbbl %eax, %eax
orl %eax, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x653ad
movq 0x8868(%r15), %rdi
callq 0x65214
movq %rax, %r14
testq %rax, %rax
jne 0x5afa6
jmp 0x5b06a
xorl %ebx, %ebx
jmp 0x5b06a
movq %r14, %rdi
xorl %esi, %esi
callq 0x653ad
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_io.c
// Function: cram_free_slice_header
void cram_free_slice_header(cram_block_slice_hdr *hdr) {
    if (!hdr)
	return;

    if (hdr->block_content_ids)
	free(hdr->block_content_ids);

    free(hdr);

    return;
}

// Assembly:
testq %rdi, %rdi
je 0x5b096
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x5b08d
callq 0x68a0
movq %rbx, %rdi
popq %rbx
jmp 0x68a0
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_io.c
// Function: cram_read_file_def
cram_file_def *cram_read_file_def(cram_fd *fd) {
    cram_file_def *def = malloc(sizeof(*def));
    if (!def)
	return NULL;

    if (26 != hread(fd->fp, &def->magic[0], 26)) {
	free(def);
	return NULL;
    }

    if (memcmp(def->magic, "CRAM", 4) != 0) {
	free(def);
	return NULL;
    }

    if (def->major_version > 3) {
	fprintf(stderr, "CRAM version number mismatch\n"
		"Expected 1.x, 2.x or 3.x, got %d.%d\n",
		def->major_version, def->minor_version);
	free(def);
	return NULL;
    }

    fd->first_container += 26;
    fd->last_slice = 0;

    return def;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1a, %r15d
movl $0x1a, %edi
callq 0x69d0
testq %rax, %rax
je 0x5b5d0
movq %rax, %rbx
movq (%r14), %r12
movq 0x8(%r12), %r13
movq 0x10(%r12), %rbp
subq %r13, %rbp
cmpq $0x1a, %rbp
cmovbq %rbp, %r15
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6570
addq %r15, %r13
movq %r13, 0x8(%r12)
cmpq $0x19, %rbp
ja 0x5b5ba
movl $0x1a, %edx
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x6b0a3
movq %rax, %r15
cmpq $0x1a, %r15
jne 0x5b5c8
cmpl $0x4d415243, (%rbx)     # imm = 0x4D415243
je 0x5b5e4
movq %rbx, %rdi
callq 0x68a0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x4(%rbx), %al
cmpb $0x4, %al
jae 0x5b600
addq $0x1a, 0x8840(%r14)
movl $0x0, 0x884c(%r14)
jmp 0x5b5d2
movzbl %al, %edi
movq %rbx, %rsi
callq 0x7960
jmp 0x5b5d0
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_io.c
// Function: cram_seek
int cram_seek(cram_fd *fd, off_t offset, int whence) {
    char buf[65536];

    fd->ooc = 0;

    if (hseek(fd->fp, offset, whence) >= 0)
	return 0;

    if (!(whence == SEEK_CUR && offset >= 0))
	return -1;

    /* Couldn't fseek, but we're in SEEK_CUR mode so read instead */
    while (offset > 0) {
	int len = MIN(65536, offset);
	if (len != hread(fd->fp, buf, len))
	    return -1;
	offset -= len;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10018, %rsp          # imm = 0x10018
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x0, 0x88f8(%rdi)
movq (%rdi), %rdi
callq 0x6b2f4
testq %rax, %rax
js 0x5cc87
xorl %eax, %eax
jmp 0x5cd0f
cmpl $0x1, %ebp
setne %al
testq %rbx, %rbx
sets %cl
orb %al, %cl
jne 0x5cd0a
leaq 0x10(%rsp), %r14
movq %r15, 0x8(%rsp)
testq %rbx, %rbx
jle 0x5cc80
movl $0x10000, %eax          # imm = 0x10000
cmpq %rax, %rbx
movl $0x10000, %r12d         # imm = 0x10000
cmovbq %rbx, %r12
movq (%r15), %rbp
movq 0x8(%rbp), %rsi
movq 0x10(%rbp), %r15
subq %rsi, %r15
cmpq %r12, %r15
movq %r12, %r13
cmovbq %r15, %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0x6570
addq %r13, 0x8(%rbp)
cmpq %r12, %r15
jae 0x5ccf8
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x6b0a3
movq %rax, %r13
subq %r12, %rbx
cmpq %r13, %r12
leaq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
je 0x5cca1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10018, %rsp          # imm = 0x10018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_io.c
// Function: cram_flush
int cram_flush(cram_fd *fd) {
    if (!fd)
	return -1;

    if (fd->mode == 'w' && fd->ctr) {
	if(fd->ctr->slice)
	    fd->ctr->curr_slice++;
	if (-1 == cram_flush_container_mt(fd, fd->ctr))
	    return -1;
    }

    return 0;
}

// Assembly:
pushq %rbx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x5cd54
cmpl $0x77, 0x8(%rdi)
jne 0x5cd52
movq 0x38(%rdi), %rsi
testq %rsi, %rsi
je 0x5cd52
cmpq $0x0, 0x80(%rsi)
je 0x5cd48
incl 0x54(%rsi)
callq 0x5af18
cmpl $-0x1, %eax
je 0x5cd54
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_stats.c
// Function: cram_stats_add
void cram_stats_add(cram_stats *st, int32_t val) {
    st->nsamp++;

    //assert(val >= 0);

    if (val < MAX_STAT_VAL && val >= 0) {
	st->freqs[val]++;
    } else {
	khint_t k;
	int r;

	if (!st->h) {
	    st->h = kh_init(m_i2i);
	}

	k = kh_put(m_i2i, st->h, val, &r);
	if (r == 0)
	    kh_val(st->h, k)++;
	else if (r != -1)
	    kh_val(st->h, k) = 1;
	//else
	    //; // FIXME: handle error
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
incl 0x1008(%rdi)
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x5db98
movl %ebp, %eax
incl (%rbx,%rax,4)
jmp 0x5dd10
movq 0x1000(%rbx), %r14
testq %r14, %r14
jne 0x5dbbd
movl $0x1, %edi
movl $0x28, %esi
callq 0x6470
movq %rax, %r14
movq %rax, 0x1000(%rbx)
movl 0x8(%r14), %eax
cmpl 0xc(%r14), %eax
jb 0x5dbea
movl (%r14), %esi
movl 0x4(%r14), %eax
addl %eax, %eax
cmpl %eax, %esi
jbe 0x5dbd8
decl %esi
jmp 0x5dbda
incl %esi
movq %r14, %rdi
callq 0x5e15a
testl %eax, %eax
js 0x5dd10
movl (%r14), %esi
leal -0x1(%rsi), %r8d
movl %r8d, %edi
andl %ebp, %edi
movq 0x10(%r14), %rax
movl %edi, %ecx
shrl $0x4, %ecx
movl (%rax,%rcx,4), %edx
leal (%rdi,%rdi), %ecx
shrl %cl, %edx
testb $0x2, %dl
je 0x5dc10
movl %edi, %edx
jmp 0x5dc8c
movl $0x1, %r10d
movl %edi, %r9d
movl %esi, %edx
movl %r9d, %ecx
shrl $0x4, %ecx
movl (%rax,%rcx,4), %r11d
leal (%r9,%r9), %ecx
andl $0x1e, %ecx
movl %r11d, %r15d
shrl %cl, %r15d
testb $0x2, %r15b
jne 0x5dc6c
testb $0x1, %r15b
jne 0x5dc4b
movq 0x18(%r14), %r15
movl %r9d, %r12d
cmpl %ebp, (%r15,%r12,4)
je 0x5dc6c
btl %ecx, %r11d
cmovbl %r9d, %edx
addl %r10d, %r9d
andl %r8d, %r9d
incl %r10d
cmpl %edi, %r9d
jne 0x5dc1b
movb $0x1, %cl
movl %esi, %r8d
cmpl %esi, %edx
je 0x5dc7c
jmp 0x5dc8c
shrl %cl, %r11d
testb $0x2, %r11b
sete %cl
movl %edx, %r8d
movl %r9d, %edi
cmpl %esi, %r8d
cmovel %edi, %r8d
testb %cl, %cl
cmovnel %edi, %r8d
movl %r8d, %edx
movl %edx, %esi
shrl $0x4, %esi
movl (%rax,%rsi,4), %edi
leal (%rdx,%rdx), %ecx
andl $0x1e, %ecx
shrl %cl, %edi
testb $0x2, %dil
jne 0x5dcba
testb $0x1, %dil
jne 0x5dce5
movq 0x1000(%rbx), %rax
movq 0x20(%rax), %rax
movl %edx, %ecx
incl (%rax,%rcx,4)
jmp 0x5dd10
movq 0x18(%r14), %rdi
movl %edx, %edx
movl %ebp, (%rdi,%rdx,4)
movl $0x3, %edi
shll %cl, %edi
notl %edi
andl %edi, (%rax,%rsi,4)
movq 0x4(%r14), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movq %xmm0, 0x4(%r14)
jmp 0x5dcfe
movq 0x18(%r14), %rdi
movl %edx, %edx
movl %ebp, (%rdi,%rdx,4)
movl $0x3, %edi
shll %cl, %edi
notl %edi
andl %edi, (%rax,%rsi,4)
incl 0x4(%r14)
movq 0x1000(%rbx), %rax
movq 0x20(%rax), %rax
movl $0x1, (%rax,%rdx,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_stats.c
// Function: cram_stats_del
void cram_stats_del(cram_stats *st, int32_t val) {
    st->nsamp--;

    //assert(val >= 0);

    if (val < MAX_STAT_VAL && val >= 0) {
	st->freqs[val]--;
	assert(st->freqs[val] >= 0);
    } else if (st->h) {
	khint_t k = kh_get(m_i2i, st->h, val);

	if (k != kh_end(st->h)) {
	    if (--kh_val(st->h, k) == 0)
		kh_del(m_i2i, st->h, k);
	} else {
	    fprintf(stderr, "Failed to remove val %d from cram_stats\n", val);
	    st->nsamp++;
	}
    } else {
	fprintf(stderr, "Failed to remove val %d from cram_stats\n", val);
	st->nsamp++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rdx
decl 0x1008(%rdi)
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x5dd63
movl %esi, %eax
movl (%rdx,%rax,4), %ecx
leal -0x1(%rcx), %esi
movl %esi, (%rdx,%rax,4)
testl %ecx, %ecx
jg 0x5de39
leaq 0x3b809(%rip), %rdi     # 0x99554
leaq 0x3b816(%rip), %rsi     # 0x99568
leaq 0x3b821(%rip), %rcx     # 0x9957a
movl $0x53, %edx
callq 0x6460
movq 0x1000(%rdx), %rdi
addq $0x1008, %rdx           # imm = 0x1008
testq %rdi, %rdi
je 0x5de2f
movl (%rdi), %r8d
testl %r8d, %r8d
je 0x5dde0
leal -0x1(%r8), %r9d
movl %r9d, %r10d
andl %esi, %r10d
movq 0x10(%rdi), %r11
movl $0x1, %ebx
movl %r10d, %eax
movl %eax, %ecx
shrl $0x4, %ecx
movl (%r11,%rcx,4), %ebp
leal (%rax,%rax), %ecx
andl $0x1e, %ecx
movl %ebp, %r14d
shrl %cl, %r14d
testb $0x2, %r14b
jne 0x5ddd4
testb $0x1, %r14b
jne 0x5ddc6
movq 0x18(%rdi), %r14
movl %eax, %r15d
cmpl %esi, (%r14,%r15,4)
je 0x5ddd4
addl %ebx, %eax
andl %r9d, %eax
incl %ebx
cmpl %r10d, %eax
jne 0x5dd98
jmp 0x5de23
shrl %cl, %ebp
testb $0x3, %bpl
cmovnel %r8d, %eax
jmp 0x5dde2
xorl %eax, %eax
cmpl %r8d, %eax
je 0x5de23
movq 0x20(%rdi), %rcx
movl %eax, %edx
decl (%rcx,%rdx,4)
jne 0x5de39
cmpl %eax, (%rdi)
je 0x5de39
movq 0x10(%rdi), %rdx
movl %eax, %esi
shrl $0x4, %esi
movl (%rdx,%rsi,4), %r8d
addl %eax, %eax
andl $0x1e, %eax
movl %r8d, %r9d
movl %eax, %ecx
shrl %cl, %r9d
testb $0x3, %r9b
jne 0x5de39
btsl %eax, %r8d
movl %r8d, (%rdx,%rsi,4)
decl 0x4(%rdi)
jmp 0x5de39
movl %esi, %edi
movq %rdx, %rsi
callq 0x7ab8
jmp 0x5de39
movl %esi, %edi
movq %rdx, %rsi
callq 0x7ada
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/mFILE.c
// Function: mfload
static char *mfload(FILE *fp, const char *fn, size_t *size, int binary) {
    struct stat sb;
    char *data = NULL;
    size_t allocated = 0, used = 0;
    int bufsize = 8192;

#ifdef _WIN32
    if (binary)
	_setmode(_fileno(fp), _O_BINARY);
    else 
	_setmode(_fileno(fp), _O_TEXT);
#endif

    if (fn && -1 != stat(fn, &sb)) {
	data = malloc(allocated = sb.st_size);
	bufsize = sb.st_size;
    } else {
	fn = NULL;
    }

    do {
	size_t len;
	if (used + bufsize > allocated) {
	    allocated += bufsize;
	    data = realloc(data, allocated);
	}
	len = fread(data + used, 1, allocated - used, fp);
	if (len > 0)
	    used += len;
    } while (!feof(fp) && (fn == NULL || used < sb.st_size));

    *size = used;

    return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %r14
movb $0x1, %al
movl %eax, 0xc(%rsp)
movl $0x2000, %ebx           # imm = 0x2000
testq %rsi, %rsi
je 0x5e982
leaq 0x18(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x6630
movq 0x30(%r15), %r15
cmpl $-0x1, %eax
je 0x5e987
movq %r15, %rdi
callq 0x69d0
movq %rax, %r12
movslq %r15d, %rbx
movl $0x0, 0xc(%rsp)
movq %r15, %r13
jmp 0x5e98d
xorl %r12d, %r12d
jmp 0x5e98a
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq (%rbx,%rbp), %rax
cmpq %r13, %rax
jbe 0x5e9a9
addq %rbx, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x6c80
movq %rax, %r12
leaq (%r12,%rbp), %rdi
movq %r13, %rdx
subq %rbp, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x6b20
addq %rax, %rbp
movq %r14, %rdi
callq 0x6bc0
cmpq %r15, %rbp
setb %cl
testl %eax, %eax
jne 0x5e9db
orb 0xc(%rsp), %cl
jne 0x5e98f
movq 0x10(%rsp), %rax
movq %rbp, (%rax)
movq %r12, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/mFILE.c
// Function: mfclose
int mfclose(mFILE *mf) {
    if (!mf)
	return -1;

    mfflush(mf);

#ifdef HAVE_MMAP
    if ((mf->mode & MF_MMAP) && mf->data) {
	/* Mmaped */
	munmap(mf->data, mf->size);
	mf->data = NULL;
    }
#endif

    if (mf->fp)
	fclose(mf->fp);

    mfdestroy(mf);

    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x5ea72
pushq %rbx
movq %rdi, %rbx
callq 0x5ea78
testb $0x40, 0x1c(%rbx)
je 0x5ea59
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x5ea59
movq 0x20(%rbx), %rsi
callq 0x63d0
movq $0x0, 0x8(%rbx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5ea66
callq 0x66e0
movq %rbx, %rdi
callq 0x5eb94
xorl %eax, %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/mFILE.c
// Function: mfdestroy
int mfdestroy(mFILE *mf) {
    if (!mf)
	return -1;

    if (mf->data)
	free(mf->data);
    free(mf);

    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x5ebb7
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5ebab
callq 0x68a0
movq %rbx, %rdi
callq 0x68a0
xorl %eax, %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/mFILE.c
// Function: mfdetach
int mfdetach(mFILE *mf) {
    if (!mf)
	return -1;

    mfflush(mf);
    if (mf->mode & MF_MMAP)
	return -1;

    if (mf->fp) {
	fclose(mf->fp);
	mf->fp = NULL;
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x5ebf0
movq %rdi, %r14
callq 0x5ea78
testb $0x40, 0x1c(%r14)
jne 0x5ebf0
movq (%r14), %rdi
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x5ebf0
callq 0x66e0
movq $0x0, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/mFILE.c
// Function: mfseek
int mfseek(mFILE *mf, long offset, int whence) {
    switch (whence) {
    case SEEK_SET:
	mf->offset = offset;
	break;
    case SEEK_CUR:
	mf->offset += offset;
	break;
    case SEEK_END:
	mf->offset = mf->size + offset;
	break;
    default:
	errno = EINVAL;
	return -1;
    }

    mf->eof = 0;
    return 0;
}

// Assembly:
cmpl $0x2, %edx
je 0x5ec6b
cmpl $0x1, %edx
je 0x5ec65
testl %edx, %edx
je 0x5ec6f
pushq %rax
callq 0x6060
movl $0x16, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
addq %rsi, 0x28(%rdi)
jmp 0x5ec73
addq 0x20(%rdi), %rsi
movq %rsi, 0x28(%rdi)
movl $0x0, 0x18(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/mFILE.c
// Function: mfprintf
int mfprintf(mFILE *mf, char *fmt, ...) {
    int ret;
    size_t est_length;
    va_list args;

    va_start(args, fmt);
    est_length = vflen(fmt, args);
    va_end(args);
    while (est_length + mf->offset > mf->alloced) {
	size_t new_alloced = mf->alloced ? mf->alloced * 2 : 1024;
	void * new_data    = realloc(mf->data, new_alloced);
	if (NULL == new_data) return -1;
	mf->alloced = new_alloced;
	mf->data    = new_data;
    }

    va_start(args, fmt);
    ret = vsprintf(&mf->data[mf->offset], fmt, args);
    va_end(args);

    if (ret > 0) {
	mf->offset += ret;
	if (mf->size < mf->offset)
	    mf->size = mf->offset;
    }

    if (mf->fp == stderr) {
	/* Auto-flush for stderr */
	if (0 != mfflush(mf)) return -1;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x5ef7b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rsi
movq %r12, 0x10(%rsi)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x65c34
movslq %eax, %r13
movq 0x28(%rbx), %rax
addq %r13, %rax
movq 0x10(%rbx), %r15
cmpq %r15, %rax
jbe 0x5eff2
movq 0x8(%rbx), %rax
movl $0x400, %ebp            # imm = 0x400
testq %r15, %r15
leaq (%r15,%r15), %r15
cmoveq %rbp, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6c80
testq %rax, %rax
je 0x5f064
movq %r15, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq 0x28(%rbx), %rcx
addq %r13, %rcx
cmpq %r15, %rcx
ja 0x5efbf
movq %rsp, %rdx
movq %r12, 0x10(%rdx)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0x8(%rbx), %rdi
addq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x6300
movl %eax, %ebp
testl %eax, %eax
jle 0x5f03c
movl %ebp, %eax
addq 0x28(%rbx), %rax
movq %rax, 0x28(%rbx)
cmpq %rax, 0x20(%rbx)
jae 0x5f03c
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movq 0x5ff92(%rip), %rcx     # 0xbefd8
cmpq (%rcx), %rax
je 0x5f04f
movl %ebp, %eax
jmp 0x5f069
movq %rbx, %rdi
callq 0x5ea78
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x5f069
jmp 0x5f04b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/open_trace_file.c
// Function: find_file_url
mFILE *find_file_url(char *file, char *url) {
    char buf[8192], *cp;
    mFILE *mf = NULL;
    int maxlen = 8190 - strlen(file), len;
    hFILE *hf;

    /* Expand %s for the trace name */
    for (cp = buf; *url && cp - buf < maxlen; url++) {
	if (*url == '%' && *(url+1) == 's') {
	    url++;
	    cp += strlen(strcpy(cp, file));
	} else {
	    *cp++ = *url;
	}
    }
    *cp++ = 0;

    if (!(hf = hopen(buf, "r")))
	return NULL;

    if (NULL == (mf = mfcreate(NULL, 0)))
	return NULL;
    while ((len = hread(hf, buf, 8192)) > 0) {
	if (mfwrite(buf, len, 1, mf) <= 0) {
	    hclose_abruptly(hf);
	    mfdestroy(mf);
	    return NULL;
	}
    }
    if (hclose(hf) < 0) {
	mfdestroy(mf);
	return NULL;
    }

    mrewind(mf);
    return mf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rsi, %rbx
movq %rdi, %r14
callq 0x62d0
movl $0x1ffe, %ecx           # imm = 0x1FFE
subl %eax, %ecx
movslq %ecx, %r12
movb (%rbx), %al
testb %al, %al
setne %cl
testq %r12, %r12
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x5f38f
movq %rsp, %r13
movq %r13, %r15
cmpb $0x25, %al
jne 0x5f372
cmpb $0x73, 0x1(%rbx)
jne 0x5f372
incq %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x6680
movq %r15, %rdi
callq 0x62d0
addq %rax, %r15
jmp 0x5f378
movb %al, (%r15)
incq %r15
movb 0x1(%rbx), %al
testb %al, %al
je 0x5f392
incq %rbx
movq %r15, %rcx
subq %r13, %rcx
cmpq %r12, %rcx
jl 0x5f34d
jmp 0x5f392
movq %rsp, %r15
movb $0x0, (%r15)
leaq 0x36b6c(%rip), %rsi     # 0x95f09
movq %rsp, %rdi
callq 0x6b721
testq %rax, %rax
je 0x5f44b
movq %rax, %r14
xorl %r15d, %r15d
xorl %edi, %edi
xorl %esi, %esi
callq 0x5e555
testq %rax, %rax
je 0x5f44e
movq %rax, %rbx
movq %rsp, %r15
movl $0x2000, %r13d          # imm = 0x2000
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rbp
subq %rsi, %rbp
cmpq %r13, %rbp
movl $0x2000, %r12d          # imm = 0x2000
cmovbq %rbp, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x6570
addq %r12, 0x8(%r14)
movl $0x2000, %eax           # imm = 0x2000
cmpq $0x1fff, %rbp           # imm = 0x1FFF
ja 0x5f41e
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x6b0a3
testl %eax, %eax
jle 0x5f463
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x5ed77
testq %rax, %rax
jne 0x5f3d2
movq %r14, %rdi
callq 0x6b3ed
movq %rbx, %rdi
callq 0x5eb94
xorl %r15d, %r15d
movq %r15, %rax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x6b393
testl %eax, %eax
js 0x5f443
movq %rbx, %rdi
callq 0x5ec82
movq %rbx, %r15
jmp 0x5f44e
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/open_trace_file.c
// Function: find_file_dir
static mFILE *find_file_dir(char *file, char *dirname) {
    char *path;
    mFILE *mf = NULL;

    path = expand_path(file, dirname);

    if (is_file(path))
	mf = mfopen(path, "rbm");

    free(path);
    return mf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x5f70e
movq %rax, %rbx
movq %rax, %rdi
callq 0x5e3fc
testl %eax, %eax
je 0x5f5fe
leaq 0x3a0b4(%rip), %rsi     # 0x996a5
movq %rbx, %rdi
callq 0x5e9f8
movq %rax, %r14
jmp 0x5f601
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x68a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/open_trace_file.c
// Function: find_path
char *find_path(char *file, char *path) {
    char *newsearch;
    char *ele;
    char *outpath = NULL;

    /* Use path first */
    if (!path)
	path = getenv("RAWDATA");
    if (NULL == (newsearch = tokenise_search_path(path)))
	return NULL;
    
    for (ele = newsearch; *ele; ele += strlen(ele)+1) {
	char *ele2 = (*ele == '|') ? ele+1 : ele;

	if (!strncmp(ele2, "URL=", 4) ||
	    !strncmp(ele2, "http:", 5) ||
	    !strncmp(ele2, "ftp:", 4)) {
	    continue;
	} else {
	    outpath = expand_path(file, ele2);
	    if (is_file(outpath)) {
		free(newsearch);
		return outpath;
	    } else {
		free(outpath);
	    }
	} 
    }

    free(newsearch);

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x5f636
leaq 0x3a06a(%rip), %rdi     # 0x99698
callq 0x68f0
movq %rax, %rsi
movq %rsi, %rdi
callq 0x5f0c8
testq %rax, %rax
je 0x5f6f9
movq %rax, %r14
movb (%rax), %al
testb %al, %al
je 0x5f6ec
leaq 0x3a045(%rip), %r15     # 0x996a0
leaq 0x3a027(%rip), %r12     # 0x99689
movq %r14, %rbp
xorl %r13d, %r13d
cmpb $0x7c, %al
sete %r13b
addq %rbp, %r13
movl $0x4, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x6330
testl %eax, %eax
je 0x5f6d3
movl $0x5, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x6330
testl %eax, %eax
je 0x5f6d3
movl $0x4, %edx
movq %r13, %rdi
leaq 0x39feb(%rip), %rsi     # 0x99693
callq 0x6330
testl %eax, %eax
je 0x5f6d3
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5f70e
movq %rax, %r13
movq %rax, %rdi
callq 0x5e3fc
testl %eax, %eax
jne 0x5f6ef
movq %r13, %rdi
callq 0x68a0
movq %rbp, %rdi
callq 0x62d0
addq %rax, %rbp
incq %rbp
movb (%rbp), %al
testb %al, %al
jne 0x5f665
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x68a0
jmp 0x5f6fc
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/sam_header.c
// Function: sam_hdr_find_key
SAM_hdr_tag *sam_hdr_find_key(SAM_hdr *sh,
			      SAM_hdr_type *type,
			      char *key,
			      SAM_hdr_tag **prev) {
    SAM_hdr_tag *tag, *p = NULL;

    for (tag = type->tag; tag; p = tag, tag = tag->next) {
	if (tag->str[0] == key[0] && tag->str[1] == key[1]) {
	    if (prev)
		*prev = p;
	    return tag;
	}
    }

    if (prev)
	*prev = p;

    return NULL;
}

// Assembly:
movq 0x10(%rsi), %r8
testq %r8, %r8
je 0x63375
movb (%rdx), %dil
xorl %esi, %esi
movq %r8, %rax
movq 0x8(%r8), %r8
cmpb %dil, (%r8)
jne 0x63368
movb 0x1(%r8), %r8b
cmpb 0x1(%rdx), %r8b
je 0x6337f
movq (%rax), %r8
movq %rax, %rsi
testq %r8, %r8
jne 0x63352
jmp 0x63377
xorl %eax, %eax
movq %rax, %rsi
movl $0x0, %eax
testq %rcx, %rcx
je 0x63387
movq %rsi, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/sam_header.c
// Function: sam_hdr_update
int sam_hdr_update(SAM_hdr *hdr, SAM_hdr_type *type, ...) {
    va_list ap;

    va_start(ap, type);
    
    for (;;) {
	char *k, *v;
	int idx;
	SAM_hdr_tag *tag, *prev;

	if (!(k = (char *)va_arg(ap, char *)))
	    break;
	v = va_arg(ap, char *);

	tag = sam_hdr_find_key(hdr, type, k, &prev);
	if (!tag) {
	    if (!(tag = pool_alloc(hdr->tag_pool)))
		return -1;
	    if (prev)
		prev->next = tag;
	    else
		type->tag = tag;

	    tag->next = NULL;
	}

	idx = ks_len(&hdr->text);
	if (ksprintf(&hdr->text, "%2.2s:%s", k, v) < 0)
	    return -1;
	tag->len = ks_len(&hdr->text) - idx;
	tag->str = string_ndup(hdr->str_pool,
			       ks_str(&hdr->text) + idx,
			       tag->len);
	if (!tag->str)
	    return -1;
    }

    va_end(ap);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x633ec
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
addq $0x10, %rsi
movq %rsi, 0x18(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl (%rsp), %eax
cmpq $0x28, %rax
ja 0x63433
movq %rax, %rcx
addq 0x10(%rsp), %rcx
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x63441
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq (%rcx), %r12
testq %r12, %r12
je 0x63513
cmpl $0x28, %eax
ja 0x63461
movl %eax, %ecx
addq 0x10(%rsp), %rcx
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x6346f
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq (%rcx), %r13
movq 0x18(%rsp), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x634a2
movb (%r12), %al
movq %rcx, %r15
movq 0x8(%rcx), %rcx
cmpb %al, (%rcx)
jne 0x63498
movb 0x1(%rcx), %cl
cmpb 0x1(%r12), %cl
je 0x634c9
movq (%r15), %rcx
testq %rcx, %rcx
jne 0x63483
jmp 0x634a5
xorl %r15d, %r15d
movq 0x30(%r14), %rdi
callq 0x86942
testq %rax, %rax
je 0x63517
testq %r15, %r15
cmoveq 0x18(%rsp), %r15
movq %rax, (%r15)
movq $0x0, (%rax)
movq %rax, %r15
movq (%r14), %rbx
movq %r14, %rdi
leaq 0x36666(%rip), %rsi     # 0x99b3c
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x6629a
testl %eax, %eax
js 0x6351c
movq (%r14), %rax
movslq %ebx, %rsi
subq %rbx, %rax
movl %eax, 0x10(%r15)
movq 0x20(%r14), %rdi
addq 0x10(%r14), %rsi
movslq %eax, %rdx
callq 0x651d9
movq %rax, 0x8(%r15)
testq %rax, %rax
jne 0x6341a
jmp 0x6351c
xorl %ebp, %ebp
jmp 0x6351c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/sam_header.c
// Function: sam_hdr_new
SAM_hdr *sam_hdr_new() {
    SAM_hdr *sh = calloc(1, sizeof(*sh));

    if (!sh)
	return NULL;
    
    sh->h = kh_init(sam_hdr);
    if (!sh->h)
	goto err;

    sh->ID_cnt = 1;
    sh->ref_count = 1;

    sh->nref = 0;
    sh->ref  = NULL;
    if (!(sh->ref_hash = kh_init(m_s2i)))
	goto err;

    sh->nrg = 0;
    sh->rg  = NULL;
    if (!(sh->rg_hash = kh_init(m_s2i)))
	goto err;

    sh->npg = 0;
    sh->pg  = NULL;
    sh->npg_end = sh->npg_end_alloc = 0;
    sh->pg_end = NULL;
    if (!(sh->pg_hash = kh_init(m_s2i)))
	goto err;

    KS_INIT(&sh->text);

    if (!(sh->tag_pool = pool_create(sizeof(SAM_hdr_tag))))
	goto err;

    if (!(sh->type_pool = pool_create(sizeof(SAM_hdr_type))))
	goto err;

    if (!(sh->str_pool = string_pool_create(8192)))
	goto err;

    return sh;

 err:
    if (sh->h)
	kh_destroy(sam_hdr, sh->h);

    if (sh->tag_pool)
	pool_destroy(sh->tag_pool);

    if (sh->type_pool)
	pool_destroy(sh->type_pool);

    if (sh->str_pool)
	string_pool_destroy(sh->str_pool);

    free(sh);

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x4a0, %esi            # imm = 0x4A0
callq 0x6470
testq %rax, %rax
je 0x63bb9
movq %rax, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x6470
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x63ba3
movq %rax, %r14
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x494(%rbx)
movl $0x1, %edi
movl $0x28, %esi
callq 0x6470
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x63b5c
movl $0x1, %edi
movl $0x28, %esi
callq 0x6470
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x63b5c
movl $0x1, %edi
movl $0x28, %esi
callq 0x6470
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x63b5c
movl $0x18, %edi
callq 0x86884
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x63b5c
movq %rax, %r12
movl $0x20, %edi
callq 0x86884
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x63bca
movq %rax, %r15
movl $0x2000, %edi           # imm = 0x2000
callq 0x65094
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x63bbb
jmp 0x63b62
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x18(%r14), %rdi
callq 0x68a0
movq 0x10(%r14), %rdi
callq 0x68a0
movq 0x20(%r14), %rdi
callq 0x68a0
movq %r14, %rdi
callq 0x68a0
testq %r12, %r12
je 0x63b96
movq %r12, %rdi
callq 0x868fd
movq 0x28(%rbx), %r15
testq %r15, %r15
je 0x63ba3
movq %r15, %rdi
callq 0x868fd
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x63bb1
callq 0x650c3
movq %rbx, %rdi
callq 0x68a0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x63b62
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/sam_header.c
// Function: sam_hdr_parse_
SAM_hdr *sam_hdr_parse_(const char *hdr, int len) {
    /* Make an empty SAM_hdr */
    SAM_hdr *sh;
    
    sh = sam_hdr_new();
    if (NULL == sh) return NULL;

    if (NULL == hdr) return sh; // empty header is permitted

    /* Parse the header, line by line */
    if (-1 == sam_hdr_add_lines(sh, hdr, len)) {
	sam_hdr_free(sh);
	return NULL;
    }

    /* Obtain sort order */
    sh->sort_order = sam_hdr_parse_sort_order(sh);

    //sam_hdr_dump(sh);
    //sam_hdr_add(sh, "RG", "ID", "foo", "SM", "bar", NULL);
    //sam_hdr_rebuild(sh);
    //printf(">>%s<<", ks_str(sh->text));

    //parse_references(sh);
    //parse_read_groups(sh);

    sam_hdr_link_pg(sh);
    //sam_hdr_dump(sh);

    return sh;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
callq 0x63a79
testq %rax, %rax
je 0x63c7f
movq %rax, %rbx
testq %r14, %r14
je 0x63d5b
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x61686
cmpl $-0x1, %eax
je 0x63c77
movq 0x18(%rbx), %rax
movl (%rax), %edx
testl %edx, %edx
je 0x63c92
leal -0x1(%rdx), %edi
movl %edi, %r8d
andl $0x4844, %r8d           # imm = 0x4844
movq 0x10(%rax), %r9
movl $0x1, %r10d
movl %r8d, %esi
movl %esi, %ecx
shrl $0x4, %ecx
movl (%r9,%rcx,4), %r11d
leal (%rsi,%rsi), %ecx
andl $0x1e, %ecx
movl %r11d, %ebp
shrl %cl, %ebp
testb $0x2, %bpl
jne 0x63c86
testb $0x1, %bpl
jne 0x63c60
movq 0x18(%rax), %r14
movl %esi, %r15d
cmpl $0x4844, (%r14,%r15,4)  # imm = 0x4844
je 0x63c86
addl %r10d, %esi
andl %edi, %esi
incl %r10d
cmpl %r8d, %esi
jne 0x63c2f
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x63d4d
movq %rbx, %rdi
callq 0x63d6d
xorl %ebx, %ebx
jmp 0x63d5b
shrl %cl, %r11d
testb $0x3, %r11b
cmovnel %edx, %esi
jmp 0x63c94
xorl %esi, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %edx, %esi
je 0x63d4d
movq 0x20(%rax), %rax
movl %esi, %edx
movq (%rax,%rdx,8), %rax
movq 0x10(%rax), %r13
testq %r13, %r13
je 0x63d4d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq 0x35eaf(%rip), %r14     # 0x99b74
leaq 0x35eb1(%rip), %r15     # 0x99b7d
movq 0x8(%r13), %rbp
cmpb $0x53, (%rbp)
jne 0x63d31
cmpb $0x4f, 0x1(%rbp)
jne 0x63d31
addq $0x3, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x6a50
testl %eax, %eax
je 0x63d42
movq %rbp, %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
je 0x63d46
movq %rbp, %rdi
leaq 0x35e7f(%rip), %rsi     # 0x99b87
callq 0x6a50
movl $0x2, %ecx
testl %eax, %eax
je 0x63d34
movq 0x5b2bb(%rip), %rax     # 0xbefd8
movq (%rax), %rdi
leaq 0x35e6b(%rip), %rsi     # 0x99b92
movq %rbp, %rdx
xorl %eax, %eax
callq 0x6a90
movl %r12d, %ecx
movq (%r13), %r13
movl %ecx, %r12d
testq %r13, %r13
jne 0x63ccc
jmp 0x63d4d
xorl %ecx, %ecx
jmp 0x63d34
movl $0x1, %ecx
jmp 0x63d34
movl %ecx, 0x90(%rbx)
movq %rbx, %rdi
callq 0x63f66
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/sam_header.c
// Function: sam_hdr_find_rg
SAM_RG *sam_hdr_find_rg(SAM_hdr *hdr, const char *rg) {
    khint_t k = kh_get(m_s2i, hdr->rg_hash, rg);
    return k == kh_end(hdr->rg_hash)
	? NULL
	: &hdr->rg[kh_val(hdr->rg_hash, k)];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x60(%rdi), %rax
movq %rax, (%rsp)
movl (%rax), %eax
testl %eax, %eax
je 0x643fd
movq %rsi, %r12
movq %rax, 0x10(%rsp)
leal -0x1(%rax), %r8d
movsbl (%rsi), %r13d
testl %r13d, %r13d
movq %rdi, 0x18(%rsp)
je 0x64405
movb 0x1(%r12), %al
testb %al, %al
je 0x64408
leaq 0x2(%r12), %rcx
movl %r13d, %edx
shll $0x5, %edx
subl %r13d, %edx
movsbl %al, %r13d
addl %edx, %r13d
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x643e2
jmp 0x64408
xorl %r15d, %r15d
jmp 0x6448e
xorl %r13d, %r13d
andl %r8d, %r13d
movq (%rsp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %r14d
movl %r13d, %r15d
movl %r8d, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movl %r15d, %eax
shrl $0x4, %eax
movl (%rdx,%rax,4), %ebx
leal (%r15,%r15), %ebp
andl $0x1e, %ebp
movl %ebx, %eax
movl %ebp, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x64479
testb $0x1, %al
jne 0x64469
movq (%rsp), %rax
movq 0x18(%rax), %rax
movl %r15d, %ecx
movq (%rax,%rcx,8), %rdi
movq %r12, %rsi
callq 0x6a50
movq 0x20(%rsp), %rdx
movl 0xc(%rsp), %r8d
testl %eax, %eax
je 0x64479
addl %r14d, %r15d
andl %r8d, %r15d
incl %r14d
cmpl %r13d, %r15d
jne 0x64426
jmp 0x64493
movl %ebp, %ecx
shrl %cl, %ebx
testb $0x3, %bl
movq 0x10(%rsp), %rax
cmovnel %eax, %r15d
movq 0x18(%rsp), %rdi
cmpl %eax, %r15d
jne 0x64497
xorl %eax, %eax
jmp 0x644ae
movq (%rsp), %rax
movq 0x20(%rax), %rax
movl %r15d, %ecx
movslq (%rax,%rcx,4), %rax
shlq $0x5, %rax
addq 0x58(%rdi), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/sam_header.c
// Function: sam_hdr_add_PG
int sam_hdr_add_PG(SAM_hdr *sh, const char *name, ...) {
    va_list args;

    if (sh->npg_end) {
	/* Copy ends array to avoid us looping while modifying it */
	int *end = malloc(sh->npg_end * sizeof(int));
	int i, nends = sh->npg_end;

	if (!end)
	    return -1;

	memcpy(end, sh->pg_end, nends * sizeof(*end));

	for (i = 0; i < nends; i++) {
	    va_start(args, name);
	    if (-1 == sam_hdr_vadd(sh, "PG", args,
				   "ID", sam_hdr_PG_ID(sh, name),
				   "PN", name,
				   "PP", sh->pg[end[i]].name,
				   NULL)) {
		free(end);
		return  -1;
	    }
	    va_end(args);
	}

	free(end);
    } else {
	va_start(args, name);
	if (-1 == sam_hdr_vadd(sh, "PG", args,
			       "ID", sam_hdr_PG_ID(sh, name),
			       "PN", name,
			       NULL))
	    return -1;
	va_end(args);
    }

    //sam_hdr_dump(sh);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x64762
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movslq 0x6c(%rdi), %r13
testq %r13, %r13
je 0x64842
leaq (,%r13,4), %r12
movq %r12, %rdi
callq 0x69d0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x648b4
movq %rax, %r15
movq 0x88(%r14), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x6570
testl %r13d, %r13d
jle 0x64836
movq %rsp, %r12
xorl %ebp, %ebp
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x644bd
movq 0x78(%r14), %r10
movslq (%r15,%rbp,4), %rcx
leaq (%rcx,%rcx,4), %r11
movq %r14, %rdi
leaq 0x3535e(%rip), %rsi     # 0x99b54
movq %r12, %rdx
leaq 0x34a09(%rip), %rcx     # 0x99209
movq %rax, %r8
leaq 0x3534d(%rip), %r9      # 0x99b57
xorl %eax, %eax
pushq $0x0
pushq (%r10,%r11,8)
leaq 0x35341(%rip), %r10     # 0x99b5a
pushq %r10
pushq %rbx
callq 0x6232c
addq $0x20, %rsp
cmpl $-0x1, %eax
je 0x648a7
incq %rbp
cmpq %rbp, %r13
jne 0x647b0
movq %r15, %rdi
callq 0x68a0
xorl %ebp, %ebp
jmp 0x648b4
leaq 0x20(%rsp), %rax
movq %rsp, %r15
movq %rax, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x644bd
leaq 0x352db(%rip), %rsi     # 0x99b54
leaq 0x34989(%rip), %rcx     # 0x99209
leaq 0x352d0(%rip), %r9      # 0x99b57
xorl %ebp, %ebp
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %r8
xorl %eax, %eax
pushq $0x0
pushq %rbx
callq 0x6232c
addq $0x10, %rsp
cmpl $-0x1, %eax
jne 0x648b4
jmp 0x648af
movq %r15, %rdi
callq 0x68a0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/string_alloc.c
// Function: string_ndup
char *string_ndup(string_alloc_t *a_str, char *instr, size_t len) {
    char *str = string_alloc(a_str, len + 1);
    
    if (NULL == str) return NULL;
    
    strncpy(str, instr, len);
    str[len] = 0;
    
    return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1(%rdx), %rsi
callq 0x65108
movq %rax, %r15
testq %rax, %rax
je 0x65208
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6380
movb $0x0, (%r15,%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/thread_pool.c
// Function: t_pool_next_result_locked
static t_pool_result *t_pool_next_result_locked(t_results_queue *q) {
    t_pool_result *r, *last;

    for (last = NULL, r = q->result_head; r; last = r, r = r->next) {
	if (r->serial == q->next_serial)
	    break;
    }

    if (r) {
	if (q->result_head == r)
	    q->result_head = r->next;
	else
	    last->next = r->next;

	if (q->result_tail == r)
	    q->result_tail = last;

	if (!q->result_head)
	    q->result_tail = NULL;

	q->next_serial++;
	q->queue_len--;
    }

    return r;
}

// Assembly:
xorl %esi, %esi
movq %rdi, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x65290
movq %rsi, %rdx
movl 0x8(%rax), %ecx
movq %rax, %rsi
cmpl 0x10(%rdi), %ecx
jne 0x6524a
cmpq %rax, (%rdi)
movq %rdx, %rsi
cmoveq %rdi, %rsi
movq (%rax), %r8
movq %r8, (%rsi)
cmpq %rax, 0x8(%rdi)
jne 0x6527a
movq %rdx, 0x8(%rdi)
cmpq $0x0, (%rdi)
jne 0x65288
movq $0x0, 0x8(%rdi)
incl %ecx
movl %ecx, 0x10(%rdi)
decl 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/thread_pool.c
// Function: t_pool_next_result_wait
t_pool_result *t_pool_next_result_wait(t_results_queue *q) {
    t_pool_result *r;

#ifdef DEBUG
    fprintf(stderr, "Waiting for result %d...\n", q->next_serial);
#endif

    pthread_mutex_lock(&q->result_m);
    while (!(r = t_pool_next_result_locked(q))) {
	/* Possible race here now avoided via _locked() call, but incase... */
	struct timeval now;
	struct timespec timeout;

	gettimeofday(&now, NULL);
	timeout.tv_sec = now.tv_sec + 10;
	timeout.tv_nsec = now.tv_usec * 1000;

	pthread_cond_timedwait(&q->result_avail_c, &q->result_m, &timeout);
    }
    pthread_mutex_unlock(&q->result_m);

    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x6ae0
movq %r14, %rdi
callq 0x65245
testq %rax, %rax
jne 0x6530a
leaq 0x48(%r14), %r15
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %r12, %rdi
xorl %esi, %esi
callq 0x6c40
movq 0x18(%rsp), %rax
addq $0xa, %rax
movq %rax, 0x8(%rsp)
imulq $0x3e8, 0x20(%rsp), %rax # imm = 0x3E8
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x6b50
movq %r14, %rdi
callq 0x65245
testq %rax, %rax
je 0x652c9
movq %rax, %rbp
movq %rbx, %rdi
callq 0x64f0
movq %rbp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/thread_pool.c
// Function: t_pool_results_queue_empty
int t_pool_results_queue_empty(t_results_queue *q) {
    int empty;

    pthread_mutex_lock(&q->result_m);
    empty = q->queue_len == 0 && q->pending == 0;
    pthread_mutex_unlock(&q->result_m);

    return empty;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x6ae0
xorl %ebp, %ebp
cmpl $0x0, 0x18(%r14)
jne 0x6534e
xorl %ebp, %ebp
cmpl $0x0, 0x1c(%r14)
sete %bpl
movq %rbx, %rdi
callq 0x64f0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/thread_pool.c
// Function: t_pool_delete_result
void t_pool_delete_result(t_pool_result *r, int free_data) {
    if (!r)
	return;

    if (free_data && r->data)
	free(r->data);

    free(r);
}

// Assembly:
testq %rdi, %rdi
je 0x653d1
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x653c8
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x653c8
callq 0x68a0
movq %rbx, %rdi
popq %rbx
jmp 0x68a0
retq