LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: code_sort
static int code_sort(const void *vp1, const void *vp2) {
    const cram_huffman_code *c1 = (const cram_huffman_code *)vp1;
    const cram_huffman_code *c2 = (const cram_huffman_code *)vp2;

    if (c1->len != c2->len)
	return c1->len - c2->len;
    else
	return c1->symbol - c2->symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xc(%rcx), %eax
je 0xd06ef
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0xd06fe
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_huffman_encode_free
void cram_huffman_encode_free(cram_codec *c) {
    if (!c)
	return;

    if (c->e_huffman.codes)
	free(c->e_huffman.codes);
    free(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xd0aa5
jmp 0xd0ac6
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xd0abd
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x6880
movq -0x8(%rbp), %rdi
callq 0x6880
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_byte_array_len_decode
int cram_byte_array_len_decode(cram_slice *slice, cram_codec *c,
			       cram_block *in, char *out,
			       int *out_size) {
    /* Fetch length */
    int32_t len = 0, one = 1;
    int r;

    r = c->byte_array_len.len_codec->decode(slice, c->byte_array_len.len_codec,
                                            in, (char *)&len, &one);
    //printf("ByteArray Len=%d\n", len);

    if (!r && c->byte_array_len.val_codec && len >= 0) {
	r = c->byte_array_len.val_codec->decode(slice,
						c->byte_array_len.val_codec,
						in, out, &len);
    } else {
	return -1;
    }

    *out_size = len;

    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 $0x0, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rsi
movq -0x20(%rbp), %rdx
leaq -0x34(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0xd2025
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xd2025
cmpl $0x0, -0x34(%rbp)
jl 0xd2025
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq *%rax
movl %eax, -0x3c(%rbp)
jmp 0xd202e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd203d
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_byte_array_len_decode_free
void cram_byte_array_len_decode_free(cram_codec *c) {
    if (!c) return;

    if (c->byte_array_len.len_codec)
	c->byte_array_len.len_codec->free(c->byte_array_len.len_codec);

    if (c->byte_array_len.val_codec)
	c->byte_array_len.val_codec->free(c->byte_array_len.val_codec);

    free(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xd2065
jmp 0xd20b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xd2086
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xd20a7
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x6880
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_decoder_init
cram_codec *cram_decoder_init(enum cram_encoding codec,
			      char *data, int size,
			      enum cram_external_type option,
			      int version) {
    if (codec >= E_NULL && codec < E_NUM_CODECS && decode_init[codec]) {
	return decode_init[codec](data, size, option, version);
    } else {
	fprintf(stderr, "Unimplemented codec of type %s\n", codec2str(codec));
	return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0xc(%rbp)
jb 0xd233d
cmpl $0xa, -0xc(%rbp)
jae 0xd233d
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x34edf(%rip), %rax     # 0x1071f0
cmpq $0x0, (%rax,%rcx,8)
je 0xd233d
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x34ecc(%rip), %rax     # 0x1071f0
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0xd2370
movq 0x32c8c(%rip), %rax     # 0x104fd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
callq 0xd4b90
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x13a6a(%rip), %rsi     # 0xe5dcb
movb $0x0, %al
callq 0x6a80
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_byte_array_len_encode
int cram_byte_array_len_encode(cram_slice *slice, cram_codec *c,
			       char *in, int in_size) {
    int32_t i32 = in_size;
    int r = 0;

    r |= c->e_byte_array_len.len_codec->encode(slice,
					       c->e_byte_array_len.len_codec,
					       (char *)&i32, 1);
    r |= c->e_byte_array_len.val_codec->encode(slice,
					       c->e_byte_array_len.val_codec,
					       in, in_size);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rsi
leaq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq *%rax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq *%rax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_byte_array_len_encode_free
void cram_byte_array_len_encode_free(cram_codec *c) {
    if (!c)
	return;

    if (c->e_byte_array_len.len_codec)
	c->e_byte_array_len.len_codec->free(c->e_byte_array_len.len_codec);

    if (c->e_byte_array_len.val_codec)
	c->e_byte_array_len.val_codec->free(c->e_byte_array_len.val_codec);

    free(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xd2415
jmp 0xd2460
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xd2436
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xd2457
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x6880
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_byte_array_len_encode_init
cram_codec *cram_byte_array_len_encode_init(cram_stats *st,
					    enum cram_external_type option,
					    void *dat,
					    int version) {
    cram_codec *c;
    cram_byte_array_len_encoder *e = (cram_byte_array_len_encoder *)dat;

    c = malloc(sizeof(*c));
    if (!c)
	return NULL;
    c->codec = E_BYTE_ARRAY_LEN;
    c->free = cram_byte_array_len_encode_free;
    c->encode = cram_byte_array_len_encode;
    c->store = cram_byte_array_len_encode_store;

    c->e_byte_array_len.len_codec = cram_encoder_init(e->len_encoding,
						      NULL, E_INT, 
						      e->len_dat,
						      version);
    c->e_byte_array_len.val_codec = cram_encoder_init(e->val_encoding,
						      NULL, E_BYTE_ARRAY, 
						      e->val_dat,
						      version);

    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x240, %edi            # imm = 0x240
callq 0x69c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xd28d0
movq $0x0, -0x8(%rbp)
jmp 0xd2966
movq -0x30(%rbp), %rax
movl $0x4, (%rax)
movq -0x30(%rbp), %rax
leaq -0x4e5(%rip), %rcx      # 0xd2400
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
leaq -0x574(%rip), %rcx      # 0xd2380
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
leaq -0x493(%rip), %rcx      # 0xd2470
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rax
movl (%rax), %edi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x24(%rbp), %r8d
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xd2970
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movl -0x24(%rbp), %r8d
xorl %eax, %eax
movl %eax, %esi
movl $0x4, %edx
callq 0xd2970
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_encoder_init
cram_codec *cram_encoder_init(enum cram_encoding codec,
			      cram_stats *st,
			      enum cram_external_type option,
			      void *dat,
			      int version) {
    if (st && !st->nvals)
	return NULL;

    if (encode_init[codec]) {
	cram_codec *r;
	if ((r = encode_init[codec](st, option, dat, version)))
	    r->out = NULL;
	return r;
    } else {
	fprintf(stderr, "Unimplemented codec of type %s\n", codec2str(codec));
	abort();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd29ab
movq -0x18(%rbp), %rax
cmpl $0x0, 0x100c(%rax)
jne 0xd29ab
movq $0x0, -0x8(%rbp)
jmp 0xd2a2e
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x34889(%rip), %rax     # 0x107240
cmpq $0x0, (%rax,%rcx,8)
je 0xd29fe
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x34876(%rip), %rax     # 0x107240
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xd29f4
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd2a2e
movq 0x325cb(%rip), %rax     # 0x104fd0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %edi
callq 0xd4b90
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x133a9(%rip), %rsi     # 0xe5dcb
movb $0x0, %al
callq 0x6a80
callq 0x63b0
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_byte_array_stop_decode_char
static int cram_byte_array_stop_decode_char(cram_slice *slice, cram_codec *c,
					    cram_block *in, char *out,
					    int *out_size) {
    cram_block *b = NULL;
    char *cp, ch;

    b = cram_get_block_by_id(slice, c->byte_array_stop.content_id);
    if (!b)
        return *out_size?-1:0;

    if (b->idx >= b->uncomp_size)
	return -1;

    cp = (char *)b->data + b->idx;
    while ((ch = *cp) != (char)c->byte_array_stop.stop) {
	if (cp - (char *)b->data >= b->uncomp_size)
	    return -1;
	*out++ = ch;
	cp++;
    }

    *out_size = cp - (char *)(b->data + b->idx);
    b->idx = cp - (char *)b->data + 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x34(%rax), %esi
callq 0xcd1d0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xd319a
movq -0x30(%rbp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xd3271
movq -0x38(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x38(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jl 0xd31b6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd3271
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x38(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb (%rax), %al
movb %al, -0x41(%rbp)
movsbl %al, %eax
movq -0x18(%rbp), %rcx
movsbl 0x30(%rcx), %ecx
cmpl %ecx, %eax
je 0xd322c
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movq -0x38(%rbp), %rcx
movslq 0x14(%rcx), %rcx
cmpq %rcx, %rax
jl 0xd320a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd3271
movb -0x41(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xd31cd
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x38(%rbp), %rdx
movslq 0x1c(%rdx), %rdx
addq %rdx, %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_byte_array_stop_encode_init
cram_codec *cram_byte_array_stop_encode_init(cram_stats *st,
					     enum cram_external_type option,
					     void *dat,
					     int version) {
    cram_codec *c;

    c = malloc(sizeof(*c));
    if (!c)
	return NULL;
    c->codec = E_BYTE_ARRAY_STOP;
    c->free = cram_byte_array_stop_encode_free;
    c->encode = cram_byte_array_stop_encode;
    c->store = cram_byte_array_stop_encode_store;

    c->e_byte_array_stop.stop = ((int *)dat)[0];
    c->e_byte_array_stop.content_id = ((int *)dat)[1];

    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x240, %edi            # imm = 0x240
callq 0x69c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xd4a55
movq $0x0, -0x8(%rbp)
jmp 0xd4ab1
movq -0x30(%rbp), %rax
movl $0x5, (%rax)
movq -0x30(%rbp), %rax
leaq -0x157a(%rip), %rcx     # 0xd34f0
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
leaq -0x17f9(%rip), %rcx     # 0xd3280
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
leaq -0x1568(%rip), %rcx     # 0xd3520
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x30(%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_encoding2str
char *cram_encoding2str(enum cram_encoding t) {
    switch (t) {
    case E_NULL:            return "NULL";
    case E_EXTERNAL:        return "EXTERNAL";
    case E_GOLOMB:          return "GOLOMB";
    case E_HUFFMAN:         return "HUFFMAN";
    case E_BYTE_ARRAY_LEN:  return "BYTE_ARRAY_LEN";
    case E_BYTE_ARRAY_STOP: return "BYTE_ARRAY_STOP";
    case E_BETA:            return "BETA";
    case E_SUBEXP:          return "SUBEXP";
    case E_GOLOMB_RICE:     return "GOLOMB_RICE";
    case E_GAMMA:           return "GAMMA";
    case E_NUM_CODECS:
    default:                return "?";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0xd4b73
movq -0x18(%rbp), %rax
leaq 0x10f31(%rip), %rcx     # 0xe5a14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x53d5(%rip), %rax      # 0xd9ec8
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
leaq 0xe2e8(%rip), %rax      # 0xe2deb
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
leaq 0x1126f(%rip), %rax     # 0xe5d7f
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
leaq 0x11269(%rip), %rax     # 0xe5d86
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
leaq 0x11264(%rip), %rax     # 0xe5d8e
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
leaq 0x11266(%rip), %rax     # 0xe5d9d
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
leaq 0x11269(%rip), %rax     # 0xe5dad
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
leaq 0x11261(%rip), %rax     # 0xe5db2
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
leaq 0x1125b(%rip), %rax     # 0xe5db9
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
leaq 0x1125a(%rip), %rax     # 0xe5dc5
movq %rax, -0x8(%rbp)
jmp 0xd4b7e
jmp 0xd4b73
leaq 0x5aee(%rip), %rax      # 0xda668
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: codec2str
static char *codec2str(enum cram_encoding codec) {
    switch (codec) {
    case E_NULL:            return "NULL";
    case E_EXTERNAL:        return "EXTERNAL";
    case E_GOLOMB:          return "GOLOMB";
    case E_HUFFMAN:         return "HUFFMAN";
    case E_BYTE_ARRAY_LEN:  return "BYTE_ARRAY_LEN";
    case E_BYTE_ARRAY_STOP: return "BYTE_ARRAY_STOP";
    case E_BETA:            return "BETA";
    case E_SUBEXP:          return "SUBEXP";
    case E_GOLOMB_RICE:     return "GOLOMB_RICE";
    case E_GAMMA:           return "GAMMA";
    case E_NUM_CODECS:
    default:                return "(unknown)";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0xd4c43
movq -0x18(%rbp), %rax
leaq 0x10e8d(%rip), %rcx     # 0xe5a40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5305(%rip), %rax      # 0xd9ec8
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
leaq 0xe218(%rip), %rax      # 0xe2deb
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
leaq 0x1119f(%rip), %rax     # 0xe5d7f
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
leaq 0x11199(%rip), %rax     # 0xe5d86
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
leaq 0x11194(%rip), %rax     # 0xe5d8e
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
leaq 0x11196(%rip), %rax     # 0xe5d9d
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
leaq 0x11199(%rip), %rax     # 0xe5dad
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
leaq 0x11191(%rip), %rax     # 0xe5db2
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
leaq 0x1118b(%rip), %rax     # 0xe5db9
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
leaq 0x1118a(%rip), %rax     # 0xe5dc5
movq %rax, -0x8(%rbp)
jmp 0xd4c4e
jmp 0xd4c43
leaq 0x111b8(%rip), %rax     # 0xe5e02
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/htslib/cram/cram_codecs.c
// Function: cram_codec_to_id
int cram_codec_to_id(cram_codec *c, int *id2) {
    int bnum1, bnum2 = -2;

    switch (c->codec) {
    case E_HUFFMAN:
	bnum1 = c->huffman.ncodes == 1 ? -2 : -1;
	break;
    case E_GOLOMB:
    case E_BETA:
    case E_SUBEXP:
    case E_GOLOMB_RICE:
    case E_GAMMA:
	bnum1 = -1;
	break;
    case E_EXTERNAL:
	bnum1 = c->external.content_id;
	break;
    case E_BYTE_ARRAY_LEN:
	bnum1 = cram_codec_to_id(c->byte_array_len.len_codec, NULL);
	bnum2 = cram_codec_to_id(c->byte_array_len.val_codec, NULL);
	break;
    case E_BYTE_ARRAY_STOP:
	bnum1 = c->byte_array_stop.content_id;
	break;
    case E_NULL:
	bnum1 = -2;
	break;
    default:
	fprintf(stderr, "Unknown codec type %d\n", c->codec);
	bnum1 = -1;
    }

    if (id2)
	*id2 = bnum2;
    return bnum1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xfffffffe, -0x18(%rbp) # imm = 0xFFFFFFFE
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x9, %rax
ja 0xd4d0f
movq -0x20(%rbp), %rax
leaq 0x10dd6(%rip), %rcx     # 0xe5a6c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0x30(%rax), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
cmpl $0x1, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0xd4d34
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0xd4d34
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xd4d34
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd4c60
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd4c60
movl %eax, -0x18(%rbp)
jmp 0xd4d34
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xd4d34
movl $0xfffffffe, -0x14(%rbp) # imm = 0xFFFFFFFE
jmp 0xd4d34
movq 0x302ba(%rip), %rax     # 0x104fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0x110c5(%rip), %rsi     # 0xe5deb
movb $0x0, %al
callq 0x6a80
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x10(%rbp)
je 0xd4d44
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/codegen.c
// Function: fiu_init_final
static void constructor_attr(250) _fiu_init_final(void)
{
	struct timeval tv;

	rec_inc();

	fiu_init(0);

	/* since we use random() in the wrappers, we need to seed it */
	gettimeofday(&tv, NULL);
	srandom(tv.tv_usec);

	rec_dec();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x18cb0(%rip), %rdi     # 0x1bff0
callq 0x3120
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
xorl %edi, %edi
callq 0x3080
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x30e0
movq -0x8(%rbp), %rax
movl %eax, %edi
callq 0x3060
leaq 0x18c7a(%rip), %rdi     # 0x1bff0
callq 0x3120
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/modules/posix.custom.c
// Function: set_ferror
void set_ferror(void * stream)
{
	char key[STREAM_KEY_SIZE];
	stream_to_key(stream, key);

	pthread_once(&ferror_hash_table_is_initialized,
			_fiu_init_ferror_hash_table);

	pthread_mutex_lock(&ferror_hash_table_mutex);

	// Use a dummy the value; we don't care about it, we only need to be able to
	// distinguish it from NULL.
	hash_set(ferror_hash_table, key, (void *) 0xDEAD);

	pthread_mutex_unlock(&ferror_hash_table_mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x134e0
leaq 0x8c88(%rip), %rdi      # 0x1c128
leaq 0x79(%rip), %rsi        # 0x13520
callq 0x3200
leaq 0x8c7d(%rip), %rdi      # 0x1c130
callq 0x3210
movq 0x8c99(%rip), %rdi      # 0x1c158
leaq -0x20(%rbp), %rsi
movl $0xdead, %edx           # imm = 0xDEAD
callq 0x3140
leaq 0x8c5c(%rip), %rdi      # 0x1c130
callq 0x3160
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/modules/posix.custom.c
// Function: fiu_init_ferror_hash_table
static void _fiu_init_ferror_hash_table(void)
{
	rec_inc();
	pthread_mutex_lock(&ferror_hash_table_mutex);

	// Create the hash table. No need for a value destructor, as our values
	// are not pointers but static values.
	ferror_hash_table = hash_create(NULL);

	pthread_mutex_unlock(&ferror_hash_table_mutex);
	rec_dec();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x13526
leaq 0x8ac2(%rip), %rdi      # 0x1bff0
callq 0x3120
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x8bec(%rip), %rdi      # 0x1c130
callq 0x3210
xorl %eax, %eax
movl %eax, %edi
callq 0x30a0
movq %rax, 0x8bff(%rip)      # 0x1c158
leaq 0x8bd0(%rip), %rdi      # 0x1c130
callq 0x3160
leaq 0x8a83(%rip), %rdi      # 0x1bff0
callq 0x3120
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/modules/posix.custom.c
// Function: get_ferror
static int get_ferror(void * stream)
{
	char key[STREAM_KEY_SIZE];
	stream_to_key(stream, key);

	pthread_once(&ferror_hash_table_is_initialized,
			_fiu_init_ferror_hash_table);

	pthread_mutex_lock(&ferror_hash_table_mutex);

	void *value = hash_get(ferror_hash_table, key);

	pthread_mutex_unlock(&ferror_hash_table_mutex);

	return value != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x134e0
leaq 0x8988(%rip), %rdi      # 0x1c128
leaq -0x287(%rip), %rsi      # 0x13520
callq 0x3200
leaq 0x897d(%rip), %rdi      # 0x1c130
callq 0x3210
movq 0x8999(%rip), %rdi      # 0x1c158
leaq -0x20(%rbp), %rsi
callq 0x31c0
movq %rax, -0x28(%rbp)
leaq 0x895d(%rip), %rdi      # 0x1c130
callq 0x3160
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/modules/posix.custom.c
// Function: clear_ferror
static void clear_ferror(void * stream)
{
	char key[STREAM_KEY_SIZE];
	stream_to_key(stream, key);

	pthread_once(&ferror_hash_table_is_initialized,
			_fiu_init_ferror_hash_table);

	pthread_mutex_lock(&ferror_hash_table_mutex);

	hash_del(ferror_hash_table, key);

	pthread_mutex_unlock(&ferror_hash_table_mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x134e0
leaq 0x87e8(%rip), %rdi      # 0x1c128
leaq -0x427(%rip), %rsi      # 0x13520
callq 0x3200
leaq 0x87dd(%rip), %rdi      # 0x1c130
callq 0x3210
movq 0x87f9(%rip), %rdi      # 0x1c158
leaq -0x20(%rbp), %rsi
callq 0x3190
leaq 0x87c1(%rip), %rdi      # 0x1c130
callq 0x3160
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: hash_create
struct hash *hash_create(void (*destructor)(void *))
{
	struct hash *h = malloc(sizeof(struct hash));
	if (h == NULL)
		return NULL;

	h->entries = malloc(sizeof(struct entry) * MIN_SIZE);
	if (h->entries == NULL) {
		free(h);
		return NULL;
	}

	memset(h->entries, 0, sizeof(struct entry) * MIN_SIZE);

	h->table_size = MIN_SIZE;
	h->nentries = 0;
	h->nremoved = 0;

	if (destructor == NULL)
		destructor = dumb_destructor;

	h->destructor = destructor;

	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x28, %edi
callq 0x3220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x14aee
movq $0x0, -0x8(%rbp)
jmp 0x14b7c
movl $0xf0, %edi
callq 0x3220
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x14b1f
movq -0x18(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
jmp 0x14b7c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0xf0, %edx
callq 0x30f0
movq -0x18(%rbp), %rax
movq $0xa, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x14b68
leaq 0x2c(%rip), %rax        # 0x14b90
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: hash_free
void hash_free(struct hash *h)
{
	size_t i;
	struct entry *entry;

	for (i = 0; i < h->table_size; i++) {
		entry = h->entries + i;
		if (entry->in_use == IN_USE) {
			h->destructor(entry->value);
			free(entry->key);
		}
	}

	free(h->entries);
	free(h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x14c0d
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x14bfd
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
jmp 0x14bff
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x14bb4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: hash_get
void *hash_get(struct hash *h, const char *key)
{
	size_t pos;
	struct entry *entry;

	pos = murmurhash2(key, strlen(key)) % h->table_size;

	for (int i = 0; i < h->table_size; i++) {
		entry = h->entries + pos;
		if (entry->in_use == NEVER) {
			/* We got to a entry never used, no match. */
			return NULL;
		} else if (entry->in_use == IN_USE &&
		           strcmp(key, entry->key) == 0) {
			/* The key matches. */
			return entry->value;
		}

		/* The key doesn't match this entry, continue with linear
		 * probing. */
		pos = (pos + 1) % h->table_size;
	}

	/* We went through the entire table and did not find the key.
	 * Note this is a pathological case that we don't expect would happen
	 * under normal operation, since we resize the table so there are
	 * always some never-used spaces. */
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x14d10
movl %eax, %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x14cfc
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x14ca9
movq $0x0, -0x8(%rbp)
jmp 0x14d04
movq -0x28(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x14cd6
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x3130
cmpl $0x0, %eax
jne 0x14cd6
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x14d04
jmp 0x14cd8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq %rdx, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x14c74
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: murmurhash2
static uint32_t murmurhash2(const char *key, size_t len)
{
	const uint32_t m = 0x5bd1e995;
	const int r = 24;
	const uint32_t seed = 0x34a4b627;

	// Initialize the hash to a 'random' value
	uint32_t h = seed ^ len;

	// Mix 4 bytes at a time into the hash
	while (len >= 4) {
		uint32_t k = *(uint32_t *)key;

		k *= m;
		k ^= k >> r;
		k *= m;

		h *= m;
		h ^= k;

		key += 4;
		len -= 4;
	}

	// Handle the last few bytes of the input array
	switch (len) {
	case 3:
		h ^= key[2] << 16;
	case 2:
		h ^= key[1] << 8;
	case 1:
		h ^= key[0];
		h *= m;
	}

	// Do a few final mixes of the hash to ensure the last few
	// bytes are well-incorporated.
	h ^= h >> 13;
	h *= m;
	h ^= h >> 15;

	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5bd1e995, -0x14(%rbp) # imm = 0x5BD1E995
movl $0x18, -0x18(%rbp)
movl $0x34a4b627, -0x1c(%rbp) # imm = 0x34A4B627
movq -0x10(%rbp), %rax
xorq $0x34a4b627, %rax       # imm = 0x34A4B627
movl %eax, -0x20(%rbp)
cmpq $0x4, -0x10(%rbp)
jb 0x14d9b
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
imull $0x5bd1e995, -0x24(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shrl $0x18, %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
imull $0x5bd1e995, -0x24(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x24(%rbp)
imull $0x5bd1e995, -0x20(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x14d3e
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
subq $0x1, %rax
je 0x14de5
jmp 0x14dab
movq -0x30(%rbp), %rax
subq $0x2, %rax
je 0x14dd4
jmp 0x14db7
movq -0x30(%rbp), %rax
subq $0x3, %rax
jne 0x14dfc
jmp 0x14dc3
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
shll $0x10, %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
shll $0x8, %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
imull $0x5bd1e995, -0x20(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
shrl $0xd, %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
imull $0x5bd1e995, -0x20(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
shrl $0xf, %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: hash_set
bool hash_set(struct hash *h, const char *key, void *value)
{
	bool r = _hash_set(h, strdup(key), value);

	if (!auto_resize_table(h)) {
		return false;
	}

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x14e90
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14fc0
testb $0x1, %al
jne 0x14e7d
movb $0x0, -0x1(%rbp)
jmp 0x14e85
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: hash_set
static bool _hash_set(struct hash *h, char *key, void *value)
{
	size_t pos;
	struct entry *entry;

	pos = murmurhash2(key, strlen(key)) % h->table_size;

	for (int i = 0; i < h->table_size; i++) {
		entry = h->entries + pos;
		if (entry->in_use == NEVER) {
			/* Use only fresh entries, reusing removed ones
			 * introduces significant complications when combined
			 * with the linear probing. */
			entry->in_use = IN_USE;
			entry->key = key;
			entry->value = value;
			h->nentries++;
			return true;
		} else if (entry->in_use == IN_USE &&
		           strcmp(key, entry->key) == 0) {
			/* The key matches, override the value. */
			h->destructor(entry->value);
			entry->value = value;
			return true;
		}

		/* The key doesn't match this entry, continue with linear
		 * probing. */
		pos = (pos + 1) % h->table_size;
	}

	/* We went through the entire table and did not find the key.
	 * Note this is a pathological case that we don't expect would happen
	 * under normal operation, since we resize the table so there are
	 * always some never-used spaces. */
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x14d10
movl %eax, %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq %rdx, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x14fa8
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x14f3f
movq -0x30(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x14fac
movq -0x30(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x14f82
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x3130
cmpl $0x0, %eax
jne 0x14f82
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x14fac
jmp 0x14f84
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq %rdx, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x14ed8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: hash_del
bool hash_del(struct hash *h, const char *key)
{
	size_t pos;
	struct entry *entry;
	bool found = false;

	pos = murmurhash2(key, strlen(key)) % h->table_size;

	for (int i = 0; i < h->table_size; i++) {
		entry = h->entries + pos;
		if (entry->in_use == NEVER) {
			/* We got to a never used key, not found. */
			return false;
		} else if (entry->in_use == IN_USE &&
		           strcmp(key, entry->key) == 0) {
			/* The key matches, remove it. */
			found = true;
			break;
		}

		/* The key doesn't match this entry, continue with linear
		 * probing. */
		pos = (pos + 1) % h->table_size;
	}

	if (!found) {
		return false;
	}

	/* Remove the entry */
	free(entry->key);
	h->destructor(entry->value);
	entry->key = NULL;
	entry->value = NULL;
	entry->in_use = REMOVED;
	h->nentries--;
	h->nremoved++;

	if (!auto_resize_table(h))
		return false;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x14d10
movl %eax, %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x15254
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1520c
movb $0x0, -0x1(%rbp)
jmp 0x152d7
movq -0x28(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x15231
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x3130
cmpl $0x0, %eax
jne 0x15231
movb $0x1, -0x29(%rbp)
jmp 0x15254
jmp 0x15233
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq %rdx, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x151d8
testb $0x1, -0x29(%rbp)
jne 0x15260
movb $0x0, -0x1(%rbp)
jmp 0x152d7
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x2, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x14fc0
testb $0x1, %al
jne 0x152d3
movb $0x0, -0x1(%rbp)
jmp 0x152d7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: cache_create
struct cache *cache_create()
{
	struct cache *c;

	c = malloc(sizeof(struct cache));
	if (c == NULL)
		return NULL;

	c->hash = hash_create(NULL);
	if (c->hash == NULL) {
		free(c);
		return NULL;
	}

	pthread_rwlock_init(&c->lock, NULL);

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x48, %edi
callq 0x3220
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15317
movq $0x0, -0x8(%rbp)
jmp 0x15360
xorl %eax, %eax
movl %eax, %edi
callq 0x30a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15347
movq -0x10(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
jmp 0x15360
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31a0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: cache_invalidate
bool cache_invalidate(struct cache *c)
{
	pthread_rwlock_wrlock(&c->lock);
	_cache_invalidate(c);
	pthread_rwlock_unlock(&c->lock);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x3070
movq -0x8(%rbp), %rdi
callq 0x153f0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x31b0
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: cache_invalidate
static void _cache_invalidate(struct cache *c)
{
	size_t i;
	struct entry *entry;

	for (i = 0; i < c->hash->table_size; i++) {
		entry = c->hash->entries + i;
		if (entry->in_use == IN_USE) {
			free(entry->key);
			entry->key = NULL;
			entry->value = NULL;
			entry->in_use = NEVER;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x15473
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x15463
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x15465
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x15404
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: cache_resize
bool cache_resize(struct cache *c, size_t new_size)
{
	pthread_rwlock_wrlock(&c->lock);
	if (new_size > c->size) {
		if (resize_table(c->hash, new_size)) {
			c->size = new_size;
			goto success;
		}
	} else {
		/* TODO: Implement shrinking. We just invalidate everything
		 * for now, and then resize. */
		_cache_invalidate(c);

		if (resize_table(c->hash, new_size)) {
			c->size = new_size;
			goto success;
		}
	}

	pthread_rwlock_unlock(&c->lock);
	return false;

success:
	pthread_rwlock_unlock(&c->lock);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x3070
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x154d1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x15530
testb $0x1, %al
jne 0x154c1
jmp 0x154cf
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x15513
jmp 0x15500
movq -0x10(%rbp), %rdi
callq 0x153f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x15530
testb $0x1, %al
jne 0x154f0
jmp 0x154fe
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x15513
jmp 0x15500
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x31b0
movb $0x0, -0x1(%rbp)
jmp 0x15524
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x31b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: resize_table
static bool resize_table(struct hash *h, size_t new_size)
{
	size_t i;
	struct entry *old_entries, *e;
	size_t old_size;

	/* Do not resize below minimum size; however, continue anyway to clear
	 * up removed entries. */
	if (new_size < MIN_SIZE) {
		new_size = MIN_SIZE;
	}

	old_entries = h->entries;
	old_size = h->table_size;

	h->entries = malloc(sizeof(struct entry) * new_size);
	if (h->entries == NULL)
		return false;

	memset(h->entries, 0, sizeof(struct entry) * new_size);
	h->table_size = new_size;
	h->nentries = 0;
	h->nremoved = 0;

	/* Insert the old entries into the new table. We use the internal
	 * version _hash_set() to avoid copying the keys again. */
	for (i = 0; i < old_size; i++) {
		e = old_entries + i;
		if (e->in_use == IN_USE)
			_hash_set(h, e->key, e->value);
	}

	free(old_entries);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0xa, -0x18(%rbp)
jae 0x1554f
movq $0xa, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
imulq $0x18, -0x18(%rbp), %rdi
callq 0x3220
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1558d
movb $0x0, -0x1(%rbp)
jmp 0x15625
movq -0x10(%rbp), %rax
movq (%rax), %rdi
imulq $0x18, -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x30f0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x15618
movq -0x28(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x15608
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x14e90
jmp 0x1560a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x155cc
movq -0x28(%rbp), %rdi
callq 0x3030
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/posix/../../libfiu/hash.c
// Function: cache_get
bool cache_get(struct cache *c, const char *key, void **value)
{
	pthread_rwlock_rdlock(&c->lock);
	struct entry *e = entry_for_key(c, key);

	*value = NULL;

	if (e->in_use != IN_USE)
		goto miss;

	if (strcmp(key, e->key) == 0) {
		*value = e->value;
		goto hit;
	} else {
		goto miss;
	}

hit:
	pthread_rwlock_unlock(&c->lock);
	return true;

miss:
	pthread_rwlock_unlock(&c->lock);
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x3100
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3170
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
cmpl $0x1, 0x10(%rax)
je 0x156d9
jmp 0x15714
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x3130
cmpl $0x0, %eax
jne 0x156ff
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x15701
jmp 0x15714
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x31b0
movb $0x1, -0x1(%rbp)
jmp 0x15725
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x31b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq