LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_decode.c
// Function: cram_decode_estimate_sizes
void cram_decode_estimate_sizes(cram_block_compression_hdr *hdr, cram_slice *s,
                                int *qual_size, int *name_size,
                                int *q_id) {
    int bnum1, bnum2;
    cram_codec *cd;

    *qual_size = 0;
    *name_size = 0;

    /* Qual */
    cd = hdr->codecs[DS_QS];
    if (cd == NULL) return;
    bnum1 = cram_codec_to_id(cd, &bnum2);
    if (bnum1 < 0 && bnum2 >= 0) bnum1 = bnum2;
    if (cram_ds_unique(hdr, cd, bnum1)) {
        cram_block *b = cram_get_block_by_id(s, bnum1);
        if (b) *qual_size = b->uncomp_size;
        if (q_id && cd->codec == E_EXTERNAL)
            *q_id = bnum1;
    }

    /* Name */
    cd = hdr->codecs[DS_RN];
    if (cd == NULL) return;
    bnum1 = cram_codec_to_id(cd, &bnum2);
    if (bnum1 < 0 && bnum2 >= 0) bnum1 = bnum2;
    if (cram_ds_unique(hdr, cd, bnum1)) {
        cram_block *b = cram_get_block_by_id(s, bnum1);
        if (b) *name_size = b->uncomp_size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x2e0(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x5182b
jmp 0x51916
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xec340
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x5184d
cmpl $0x0, -0x30(%rbp)
jl 0x5184d
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x51920
cmpl $0x0, %eax
je 0x518a1
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x51a00
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x51886
movq -0x40(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x5189f
movq -0x38(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x5189f
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x518a1
movq -0x8(%rbp), %rax
movq 0x2d8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x518b9
jmp 0x51916
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xec340
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x518db
cmpl $0x0, -0x30(%rbp)
jl 0x518db
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x51920
cmpl $0x0, %eax
je 0x51916
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x51a00
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x51914
movq -0x48(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x51916
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_decode.c
// Function: cram_ds_unique
static int cram_ds_unique(cram_block_compression_hdr *hdr, cram_codec *c,
                          int id) {
    int i, n_id = 0;
    enum cram_encoding e_type = 0;

    for (i = 0; i < DS_END; i++) {
        cram_codec *c;
        int bnum1, bnum2, old_n_id;

        if (!(c = hdr->codecs[i]))
            continue;

        bnum1 = cram_codec_to_id(c, &bnum2);

        old_n_id = n_id;
        if (bnum1 == id) {
            n_id++;
            e_type = c->codec;
        }
        if (bnum2 == id) {
            n_id++;
            e_type = c->codec;
        }

        if (n_id == old_n_id+2)
            n_id--; // len/val in same place counts once only.
    }

    return n_id == 1 ? e_type : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x2f, -0x18(%rbp)
jge 0x519de
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x280(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x5196e
jmp 0x519d0
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xec340
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x5199e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x519b8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl -0x34(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jne 0x519ce
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x519d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x51948
cmpl $0x1, -0x1c(%rbp)
jne 0x519ec
movl -0x20(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x519f3
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x519f3
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_io.h
// Function: cram_get_block_by_id
static inline cram_block *cram_get_block_by_id(cram_slice *slice, int id) {
  //fprintf(stderr, "%d\t%p\n", id, slice->block_by_id);
    uint32_t v = id;
    if (slice->block_by_id && v < 256) {
        return slice->block_by_id[v];
    } else {
        v = 256 + v % 251;
        if (slice->block_by_id &&
            slice->block_by_id[v] &&
            slice->block_by_id[v]->content_id == id)
            return slice->block_by_id[v];

        // Otherwise a linear search in case of collision
        int i;
        for (i = 0; i < slice->hdr->num_blocks; i++) {
            cram_block *b = slice->block[i];
            if (b && b->content_type == EXTERNAL && b->content_id == id)
                return b;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x51a3d
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jae 0x51a3d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x51b03
movl -0x18(%rbp), %eax
movl $0xfb, %ecx
xorl %edx, %edx
divl %ecx
addl $0x100, %edx            # imm = 0x100
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x51a9b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x18(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x51a9b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl 0xc(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x51a9b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x51b03
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x28(%rcx), %eax
jge 0x51af9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x51aec
movq -0x28(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x51aec
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x51aec
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x51b03
jmp 0x51aee
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x51aa2
jmp 0x51afb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_io.h
// Function: block_resize_exact
static inline int block_resize_exact(cram_block *b, size_t len) {
    unsigned char *tmp = realloc(b->data, len);
    if (!tmp)
        return -1;
    b->alloc = len;
    b->data = tmp;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4820
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x54305
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54324
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_decode.c
// Function: md5_print
static char *md5_print(unsigned char *md5, char *out) {
    int i;
    for (i = 0; i < 16; i++) {
        out[i*2+0] = "0123456789abcdef"[md5[i]>>4];
        out[i*2+1] = "0123456789abcdef"[md5[i]&15];
    }
    out[32] = 0;

    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x543b0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x9f70a(%rip), %rax     # 0xf3a6c
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x9f6dc(%rip), %rax     # 0xf3a6c
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x54343
movq -0x10(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_decode.c
// Function: cram_decode_tlen
static int cram_decode_tlen(cram_fd *fd, cram_container *c, cram_slice *s,
                            cram_block *blk, int64_t *tlen) {
    int out_sz = 1, r = 0;

    if (!c->comp_hdr->codecs[DS_TS]) return -1;
    if (CRAM_MAJOR_VERS(fd->version) < 4) {
        int32_t i32;
        r |= c->comp_hdr->codecs[DS_TS]
            ->decode(s, c->comp_hdr->codecs[DS_TS], blk,
                     (char *)&i32, &out_sz);
        *tlen = i32;
    } else {
        r |= c->comp_hdr->codecs[DS_TS]
            ->decode(s, c->comp_hdr->codecs[DS_TS], blk,
                     (char *)tlen, &out_sz);
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x330(%rax)
jne 0x54438
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x544ce
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
sarl $0x8, %eax
cmpl $0x4, %eax
jge 0x5448e
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x330(%rax), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq 0x330(%rcx), %rsi
movq -0x28(%rbp), %rdx
leaq -0x3c(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq *%rax
orl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movslq -0x3c(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x544c8
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x330(%rax), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq 0x330(%rcx), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq *%rax
orl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_io.h
// Function: block_resize
static inline int block_resize(cram_block *b, size_t len) {
    if (b->alloc > len)
        return 0;

#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    // Removal of extra padding causes many more reallocs, but detects
    // more buffer overruns.
    return block_resize_exact(b, len?len:1);
#endif

    size_t alloc = b->alloc+800;
    alloc = MAX(alloc + (alloc>>2), len);
    return block_resize_exact(b, alloc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x54d67
movl $0x0, -0x4(%rbp)
jmp 0x54dc3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x320, %rax            # imm = 0x320
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x2, %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jbe 0x54da3
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x54dab
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x542d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_decode.c
// Function: cram_decode_slice_mt
int cram_decode_slice_mt(cram_fd *fd, cram_container *c, cram_slice *s,
                         sam_hdr_t *bfd) {
    cram_decode_job *j;
    int nonblock;

    if (!fd->pool)
        return cram_decode_slice(fd, c, s, bfd);

    if (!(j = malloc(sizeof(*j))))
        return -1;

    j->fd = fd;
    j->c  = c;
    j->s  = s;
    j->h  = bfd;

    nonblock = hts_tpool_process_sz(fd->rqueue) ? 1 : 0;

    int saved_errno = errno;
    errno = 0;
    if (-1 == hts_tpool_dispatch2(fd->pool, fd->rqueue, cram_decode_slice_thread,
                                  j, nonblock)) {
        /* Would block */
        if (errno != EAGAIN)
            return -1;
        fd->job_pending = j;
    } else {
        fd->job_pending = NULL;
    }
    errno = saved_errno;

    // flush too
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88b8(%rax)
jne 0x57f43
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x51f70
movl %eax, -0x4(%rbp)
jmp 0x58048
movl $0x28, %edi
callq 0x4650
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x57f63
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x58048
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x88c0(%rax), %rdi
callq 0x4d2e0
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x34(%rbp)
callq 0x4050
movl (%rax), %eax
movl %eax, -0x38(%rbp)
callq 0x4050
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x88b8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x88c0(%rax), %rsi
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %r8d
leaq -0x13e(%rip), %rdx      # 0x57eb0
callq 0x4e540
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x58022
callq 0x4050
cmpl $0xb, (%rax)
je 0x58011
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x58048
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8970(%rax)
jmp 0x58031
movq -0x10(%rbp), %rax
movq $0x0, 0x8970(%rax)
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x4050
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_io.h
// Function: append_uint64
static inline unsigned char *append_uint64(unsigned char *cp, uint64_t i) {
    uint64_t j;

    if (i <= 0xffffffff)
        return append_uint32(cp, i);

    if ((j = i/1000000000) > 1000000000) {
        cp = append_uint32(cp, j/1000000000);
        j %= 1000000000;
        cp = append_sub32(cp, j);
    } else {
        cp = append_uint32(cp, i / 1000000000);
    }
    cp = append_sub32(cp, i % 1000000000);

    return cp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
ja 0x58723
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x59f60
movq %rax, -0x8(%rbp)
jmp 0x587c3
movq -0x18(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
cmpq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
jbe 0x58781
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movl %eax, %esi
callq 0x59f60
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x5a3f0
movq %rax, -0x10(%rbp)
jmp 0x5879e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movl %eax, %esi
callq 0x59f60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movl %edx, %esi
callq 0x5a3f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_decode.c
// Function: cram_get_bam_seq
int cram_get_bam_seq(cram_fd *fd, bam_seq_t **bam) {
    cram_record *cr;
    cram_container *c;
    cram_slice *s;

    if (!(cr = cram_get_seq(fd)))
        return -1;

    c = fd->ctr;
    s = c->slice;

    return cram_to_bam(fd->header, fd, s, cr, s->curr_rec-1, bam);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x592a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5958c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x595d6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movl 0xe4(%rax), %r8d
subl $0x1, %r8d
movq -0x18(%rbp), %r9
callq 0x58060
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_decode.c
// Function: map_find
static cram_map *map_find(cram_map **map, unsigned char *key, int id) {
    cram_map *m;

    m = map[CRAM_MAP(key[0],key[1])];
    while (m && m->key != id)
        m= m->next;

    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
imull $0x3, %ecx, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x1(%rdx), %edx
addl %edx, %ecx
andl $0x1f, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x59e40
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x59e49
jmp 0x59e57
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x59e25
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_decode.c
// Function: add_md_char
static inline int add_md_char(cram_slice *s, int decode_md, char c, int32_t *md_dist) {
    if (decode_md) {
        BLOCK_APPEND_UINT(s->aux_blk, *md_dist);
        BLOCK_APPEND_CHAR(s->aux_blk, c);
        *md_dist = 0;
    }
    return 0;

 block_err:
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x59ec0
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x59ee0
cmpl $0x0, %eax
jge 0x59e9b
jmp 0x59ec9
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
movsbl -0x15(%rbp), %esi
callq 0x4f070
cmpl $0x0, %eax
jge 0x59eb6
jmp 0x59ec9
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x59ed0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_io.h
// Function: block_append_uint
static inline int block_append_uint(cram_block *b, unsigned int i) {
    if (block_grow(b, 11) < 0)
        return -1;

    unsigned char *cp = &b->data[b->byte];
    b->byte += append_uint32(cp, i) - cp;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb, %esi
callq 0x59830
cmpl $0x0, %eax
jge 0x59f0b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x59f48
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x30(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x59f60
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
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/cram/cram_encode.c
// Function: cram_update_curr_slice
void cram_update_curr_slice(cram_container *c, int version) {
    cram_slice *s = c->slice;
    if (c->multi_seq) {
        s->hdr->ref_seq_id    = -2;
        s->hdr->ref_seq_start = 0;
        s->hdr->ref_seq_span  = 0;
    } else if (c->curr_ref == -1 && CRAM_ge31(version)) {
        // Spec states span=0, but it broke our range queries.
        // See commit message for this and prior.
        s->hdr->ref_seq_id    = -1;
        s->hdr->ref_seq_start = 0;
        s->hdr->ref_seq_span  = 0;
    } else {
        s->hdr->ref_seq_id    = c->curr_ref;
        s->hdr->ref_seq_start = c->first_base;
        s->hdr->ref_seq_span  = MAX(0, c->last_base - c->first_base + 1);
    }
    s->hdr->num_records   = c->curr_rec;

    if (c->curr_slice == 0) {
        if (c->ref_seq_id != s->hdr->ref_seq_id)
            c->ref_seq_id  = s->hdr->ref_seq_id;
        c->ref_seq_start = c->first_base;
    }

    c->curr_slice++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xac(%rax)
je 0x621b8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl $0xfffffffe, 0x4(%rax)  # imm = 0xFFFFFFFE
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
jmp 0x62278
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x78(%rax)
jne 0x621f9
cmpl $0x301, -0xc(%rbp)      # imm = 0x301
jl 0x621f9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
jmp 0x62276
movq -0x8(%rbp), %rax
movl 0x78(%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
movq -0x8(%rbp), %rax
subq 0xc8(%rax), %rcx
addq $0x1, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jle 0x62249
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x62267
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0xc8(%rcx), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x62278
movq -0x8(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x622ca
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x4(%rcx), %eax
je 0x622b7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: expected_template_count
static int expected_template_count(bam_seq_t *b) {
    int expected = bam_flag(b) & BAM_FPAIRED ? 2 : 1;

    uint8_t *TC = (uint8_t *)bam_aux_get(b, "TC");
    if (TC) {
        int n = bam_aux2i_end(TC, (uint8_t *)bam_data_end(b));
        if (expected < n)
            expected = n;
    }

    if (!TC && bam_aux_get(b, "SA")) {
        // We could count the semicolons, but we'd have to do this for
        // read1, read2 and read(not-1-or-2) combining the results
        // together.  This is a cheap and safe alternative for now.
        expected = INT_MAX;
    }

    return expected;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x10(%rax), %edx
andl $0x1, %edx
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x90ba5(%rip), %rsi     # 0xf41ea
callq 0x3e760
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x63685
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x63d70
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x63bc0
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x63683
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x63685
cmpq $0x0, -0x18(%rbp)
jne 0x636a9
movq -0x8(%rbp), %rdi
leaq 0x90fc9(%rip), %rsi     # 0xf4660
callq 0x3e760
cmpq $0x0, %rax
je 0x636a9
movl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: next_cigar_op
static inline
int next_cigar_op(uint32_t *cigar, uint32_t ncigar, int *skip, int *spos,
                  uint32_t *cig_ind, uint32_t *cig_op, uint32_t *cig_len) {
    for(;;) {
        while (*cig_len == 0) {
            if (*cig_ind < ncigar) {
                *cig_op  = cigar[*cig_ind] & BAM_CIGAR_MASK;
                *cig_len = cigar[*cig_ind] >> BAM_CIGAR_SHIFT;
                (*cig_ind)++;
            } else {
                return -1;
            }
        }

        if (skip[*cig_op]) {
            *spos += (bam_cigar_type(*cig_op)&1) * *cig_len;
            *cig_len = 0;
            continue;
        }

        (*cig_len)--;
        break;
    }

    return *cig_op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
jmp 0x64e81
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x64ed9
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0x64ece
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl (%rax,%rcx,4), %ecx
andl $0xf, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl (%rax,%rcx,4), %ecx
shrl $0x4, %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x64ed7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x64f32
jmp 0x64e81
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movl (%rcx), %ecx
cmpl $0x0, (%rax,%rcx,4)
je 0x64f1e
movq -0x38(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movl $0x3c1a7, %eax          # imm = 0x3C1A7
sarl %cl, %eax
movl %eax, %ecx
andl $0x3, %ecx
andl $0x1, %ecx
movq 0x10(%rbp), %rax
imull (%rax), %ecx
movq -0x28(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x64e7f
movq 0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: cram_add_substitution
static int cram_add_substitution(cram_fd *fd, cram_container *c,
                                 cram_slice *s, cram_record *r,
                                 int pos, char base, char qual, char ref) {
    cram_feature f;

    // seq=ACGTN vs ref=ACGT or seq=ACGT vs ref=ACGTN
    if (fd->L2[(uc)base]<4 || (fd->L2[(uc)base]<5 && fd->L2[(uc)ref]<4)) {
        f.X.pos = pos+1;
        f.X.code = 'X';
        f.X.base = fd->cram_sub_matrix[ref&0x1f][base&0x1f];
        if (cram_stats_add(c->stats[DS_BS], f.X.base) < 0)
            return -1;
    } else {
        f.B.pos = pos+1;
        f.B.code = 'B';
        f.B.base = base;
        f.B.qual = qual;
        if (cram_stats_add(c->stats[DS_BA], f.B.base) < 0) return -1;
        if (cram_stats_add(c->stats[DS_QS], f.B.qual) < 0) return -1;
        BLOCK_APPEND_CHAR(s->qual_blk, qual);
    }
    return cram_add_feature(c, s, r, &f);

 block_err:
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movb 0x18(%rbp), %r9b
movb 0x10(%rbp), %r9b
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movb %al, -0x2d(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x2d(%rbp), %ecx
movzbl 0x8370(%rax,%rcx), %eax
cmpl $0x4, %eax
jl 0x66779
movq -0x10(%rbp), %rax
movzbl -0x2d(%rbp), %ecx
movzbl 0x8370(%rax,%rcx), %eax
cmpl $0x5, %eax
jge 0x667dc
movq -0x10(%rbp), %rax
movzbl 0x18(%rbp), %ecx
movzbl 0x8370(%rax,%rcx), %eax
cmpl $0x4, %eax
jge 0x667dc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl $0x58, -0x3c(%rbp)
movq -0x10(%rbp), %rax
addq $0x8470, %rax           # imm = 0x8470
movsbl 0x18(%rbp), %ecx
andl $0x1f, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl -0x2d(%rbp), %ecx
andl $0x1f, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x1f0(%rax), %rdi
movslq -0x38(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x667da
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66879
jmp 0x66858
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl $0x42, -0x3c(%rbp)
movsbl -0x2d(%rbp), %eax
movl %eax, -0x38(%rbp)
movsbl 0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq 0x1e8(%rax), %rdi
movslq -0x38(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x6681c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66879
movq -0x18(%rbp), %rax
movq 0x158(%rax), %rdi
movslq -0x34(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x6683e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66879
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rdi
movsbl 0x10(%rbp), %esi
callq 0x5c330
cmpl $0x0, %eax
jge 0x66856
jmp 0x66872
jmp 0x66858
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x689b0
movl %eax, -0x4(%rbp)
jmp 0x66879
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: cram_add_bases
static int cram_add_bases(cram_fd *fd, cram_container *c,
                          cram_slice *s, cram_record *r,
                          int pos, int len, char *base) {
    cram_feature f;

    f.b.pos = pos+1;
    f.b.code = 'b';
    f.b.seq_idx = base - (char *)BLOCK_DATA(s->seqs_blk);
    f.b.len = len;

    return cram_add_feature(c, s, r, &f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl $0x62, -0x34(%rbp)
movq 0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x70(%rcx), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x689b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: cram_add_base
static int cram_add_base(cram_fd *fd, cram_container *c,
                         cram_slice *s, cram_record *r,
                         int pos, char base, char qual) {
    cram_feature f;
    f.B.pos = pos+1;
    f.B.code = 'B';
    f.B.base = base;
    f.B.qual = qual;
    if (cram_stats_add(c->stats[DS_BA], base) < 0) return -1;
    if (cram_stats_add(c->stats[DS_QS], qual) < 0) return -1;
    BLOCK_APPEND_CHAR(s->qual_blk, qual);
    return cram_add_feature(c, s, r, &f);

 block_err:
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movb 0x10(%rbp), %r9b
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movb %al, -0x2d(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl $0x42, -0x3c(%rbp)
movsbl -0x2d(%rbp), %eax
movl %eax, -0x38(%rbp)
movsbl 0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq 0x1e8(%rax), %rdi
movsbq -0x2d(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x66967
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x669c3
movq -0x18(%rbp), %rax
movq 0x158(%rax), %rdi
movsbq 0x10(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x6698a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x669c3
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rdi
movsbl 0x10(%rbp), %esi
callq 0x5c330
cmpl $0x0, %eax
jge 0x669a2
jmp 0x669bc
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x689b0
movl %eax, -0x4(%rbp)
jmp 0x669c3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: cram_add_deletion
static int cram_add_deletion(cram_container *c, cram_slice *s, cram_record *r,
                             int pos, int len, char *base) {
    cram_feature f;
    f.D.pos = pos+1;
    f.D.code = 'D';
    f.D.len = len;
    if (cram_stats_add(c->stats[DS_DL], len) < 0) return -1;
    return cram_add_feature(c, s, r, &f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl $0x44, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x1e0(%rax), %rdi
movslq -0x28(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x66b47
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66b5f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x689b0
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/cram/cram_encode.c
// Function: cram_add_skip
static int cram_add_skip(cram_container *c, cram_slice *s, cram_record *r,
                         int pos, int len, char *base) {
    cram_feature f;
    f.S.pos = pos+1;
    f.S.code = 'N';
    f.S.len = len;
    if (cram_stats_add(c->stats[DS_RS], len) < 0) return -1;
    return cram_add_feature(c, s, r, &f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl $0x4e, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x208(%rax), %rdi
movslq -0x28(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x66bc7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66bdf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x689b0
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/cram/cram_encode.c
// Function: cram_add_insertion
static int cram_add_insertion(cram_container *c, cram_slice *s, cram_record *r,
                              int pos, int len, char *base) {
    cram_feature f;
    f.I.pos = pos+1;
    if (len == 1) {
        char b = base ? *base : 'N';
        f.i.code = 'i';
        f.i.base = b;
        if (cram_stats_add(c->stats[DS_BA], b) < 0) return -1;
    } else {
        f.I.code = 'I';
        f.I.len = len;
        f.S.seq_idx = BLOCK_SIZE(s->base_blk);
        if (base) {
            BLOCK_APPEND(s->base_blk, base, len);
        } else {
            int i;
            for (i = 0; i < len; i++)
                BLOCK_APPEND_CHAR(s->base_blk, 'N');
        }
        BLOCK_APPEND_CHAR(s->base_blk, '\0');
    }
    return cram_add_feature(c, s, r, &f);

 block_err:
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
cmpl $0x1, -0x28(%rbp)
jne 0x66c7a
cmpq $0x0, -0x30(%rbp)
je 0x66c31
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x66c3b
movl $0x4e, %eax
movl %eax, -0x4c(%rbp)
jmp 0x66c3b
movl -0x4c(%rbp), %eax
movb %al, -0x41(%rbp)
movl $0x69, -0x3c(%rbp)
movsbl -0x41(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x1e8(%rax), %rdi
movsbq -0x41(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x66c75
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66d37
jmp 0x66d16
movl $0x49, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq 0x30(%rax), %rax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x66cc1
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x30(%rbp), %rsi
movslq -0x28(%rbp), %rdx
callq 0x5c2b0
cmpl $0x0, %eax
jge 0x66cbf
jmp 0x66d30
jmp 0x66cfb
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x66cf9
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
movl $0x4e, %esi
callq 0x5c330
cmpl $0x0, %eax
jge 0x66cec
jmp 0x66d30
jmp 0x66cee
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x66cc8
jmp 0x66cfb
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
xorl %esi, %esi
callq 0x5c330
cmpl $0x0, %eax
jge 0x66d14
jmp 0x66d30
jmp 0x66d16
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x689b0
movl %eax, -0x4(%rbp)
jmp 0x66d37
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: cram_add_quality
static int cram_add_quality(cram_fd *fd, cram_container *c,
                            cram_slice *s, cram_record *r,
                            int pos, char qual) {
    cram_feature f;
    f.Q.pos = pos+1;
    f.Q.code = 'Q';
    f.Q.qual = qual;
    if (cram_stats_add(c->stats[DS_QS], qual) < 0) return -1;
    BLOCK_APPEND_CHAR(s->qual_blk, qual);
    return cram_add_feature(c, s, r, &f);

 block_err:
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movb %al, -0x2d(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl $0x51, -0x3c(%rbp)
movsbl -0x2d(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x158(%rax), %rdi
movsbq -0x2d(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x66d9c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66dd5
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rdi
movsbl -0x2d(%rbp), %esi
callq 0x5c330
cmpl $0x0, %eax
jge 0x66db4
jmp 0x66dce
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x689b0
movl %eax, -0x4(%rbp)
jmp 0x66dd5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: cram_add_softclip
static int cram_add_softclip(cram_container *c, cram_slice *s, cram_record *r,
                             int pos, int len, char *base, int version) {
    cram_feature f;
    f.S.pos = pos+1;
    f.S.code = 'S';
    f.S.len = len;
    switch (CRAM_MAJOR_VERS(version)) {
    case 1:
        f.S.seq_idx = BLOCK_SIZE(s->base_blk);
        BLOCK_APPEND(s->base_blk, base, len);
        BLOCK_APPEND_CHAR(s->base_blk, '\0');
        break;

    case 2:
    default:
        f.S.seq_idx = BLOCK_SIZE(s->soft_blk);
        if (base) {
            BLOCK_APPEND(s->soft_blk, base, len);
        } else {
            int i;
            for (i = 0; i < len; i++)
                BLOCK_APPEND_CHAR(s->soft_blk, 'N');
        }
        BLOCK_APPEND_CHAR(s->soft_blk, '\0');
        break;

        //default:
        //    // v3.0 onwards uses BB data-series
        //    f.S.seq_idx = BLOCK_SIZE(s->soft_blk);
    }
    return cram_add_feature(c, s, r, &f);

 block_err:
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x24(%rbp), %eax
incl %eax
movl %eax, -0x40(%rbp)
movl $0x53, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
movl 0x10(%rbp), %eax
sarl $0x8, %eax
movl %eax, -0x48(%rbp)
subl $0x1, %eax
je 0x66e31
jmp 0x66e27
movl -0x48(%rbp), %eax
subl $0x2, %eax
je 0x66e86
jmp 0x66e88
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq 0x30(%rax), %rax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x30(%rbp), %rsi
movslq -0x28(%rbp), %rdx
callq 0x5c2b0
cmpl $0x0, %eax
jge 0x66e65
jmp 0x66f31
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
xorl %esi, %esi
callq 0x5c330
cmpl $0x0, %eax
jge 0x66e81
jmp 0x66f31
jmp 0x66f17
jmp 0x66e88
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq 0x30(%rax), %rax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x66ec2
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x30(%rbp), %rsi
movslq -0x28(%rbp), %rdx
callq 0x5c2b0
cmpl $0x0, %eax
jge 0x66ec0
jmp 0x66f31
jmp 0x66efc
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x66efa
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdi
movl $0x4e, %esi
callq 0x5c330
cmpl $0x0, %eax
jge 0x66eed
jmp 0x66f31
jmp 0x66eef
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x66ec9
jmp 0x66efc
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdi
xorl %esi, %esi
callq 0x5c330
cmpl $0x0, %eax
jge 0x66f15
jmp 0x66f31
jmp 0x66f17
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x689b0
movl %eax, -0x4(%rbp)
jmp 0x66f38
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: cram_add_pad
static int cram_add_pad(cram_container *c, cram_slice *s, cram_record *r,
                        int pos, int len, char *base) {
    cram_feature f;
    f.S.pos = pos+1;
    f.S.code = 'P';
    f.S.len = len;
    if (cram_stats_add(c->stats[DS_PD], len) < 0) return -1;
    return cram_add_feature(c, s, r, &f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl $0x50, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rdi
movslq -0x28(%rbp), %rsi
callq 0x7ec30
cmpl $0x0, %eax
jge 0x67027
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6703f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x689b0
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/cram/cram_index.c
// Function: kget_int32
static int kget_int32(kstring_t *k, size_t *pos, int32_t *val_p) {
    int sign = 1;
    int32_t val = 0;
    size_t p = *pos;

    while (p < k->l && (k->s[p] == ' ' || k->s[p] == '\t'))
        p++;

    if (p < k->l && k->s[p] == '-')
        sign = -1, p++;

    if (p >= k->l || !(k->s[p] >= '0' && k->s[p] <= '9'))
        return -1;

    while (p < k->l && k->s[p] >= '0' && k->s[p] <= '9') {
        int digit = k->s[p++]-'0';
        val = val*10 + digit;
    }

    *pos = p;
    *val_p = sign*val;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x35(%rbp)
jae 0x6ac74
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x36(%rbp)
je 0x6ac6e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x36(%rbp)
movb -0x36(%rbp), %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x6ac7d
jmp 0x6ac8b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6ac29
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x6acc0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x6acc0
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x6acf7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x6acf7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x6ad03
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6ad9f
jmp 0x6ad05
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x37(%rbp)
jae 0x6ad4a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x37(%rbp)
jl 0x6ad4a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x37(%rbp)
movb -0x37(%rbp), %al
testb $0x1, %al
jne 0x6ad53
jmp 0x6ad80
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movl %eax, -0x34(%rbp)
imull $0xa, -0x28(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x6ad05
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
imull -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)