LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_list_remove
void xlink_list_remove(xlink_list *list, int index) {
  XLINK_ERROR(index < 0 || index >= list->length,
   ("Cannot remove element at position %i, length = %i", index, list->length));
  list->length--;
  if (list->length > index) {
    memmove(xlink_list_get(list, index), xlink_list_get(list, index + 1),
     list->size*(list->length - index));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xcba1
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0xcbc3
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x38b6(%rip), %rdi      # 0x10468
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xcbc5
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0xcc21
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc870
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0xc870
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl -0xc(%rbp), %eax
cltq
imulq %rax, %rdx
callq 0x2170
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_list_swap
void xlink_list_swap(xlink_list *list, int i, int j) {
  XLINK_ERROR(i < 0 || i >= list->length || j < 0 || j >= list->length,
   ("Cannot swap elements at %i and %i, length = %i", i, j, list->length));
  if (i != j) {
    void *a, *b, *c;
    xlink_list_expand_capacity(list, list->length + 1);
    a = xlink_list_get(list, i);
    b = xlink_list_get(list, j);
    c = &list->data[list->length*list->size];
    memcpy(c, a, list->size);
    memcpy(a, b, list->size);
    memcpy(b, c, list->size);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xcc66
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xcc66
cmpl $0x0, -0x10(%rbp)
jl 0xcc66
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0xcc8b
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
leaq 0x3820(%rip), %rdi      # 0x1049a
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xcc8d
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0xcd2a
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
addl $0x1, %esi
callq 0xc6e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc870
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xc870
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movq -0x8(%rbp), %rdx
imulq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2100
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2100
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2100
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_set_init
void xlink_set_init(xlink_set *set, xlink_hash_code_func hash_code,
 xlink_equals_func equals, size_t value_size, int capacity, float load) {
  set->hash_code = hash_code;
  set->equals = equals;
  set->capacity = XLINK_MAX(4, capacity);
  set->load = load;
  set->table = xlink_malloc(set->capacity*sizeof(int));
  xlink_list_init(&set->entries, sizeof(xlink_entry), capacity);
  xlink_list_init(&set->values, value_size, capacity);
  xlink_set_reset(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movss %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x4, %eax
cmpl -0x24(%rbp), %eax
jl 0xce0c
movl $0x4, %eax
movl %eax, -0x2c(%rbp)
jmp 0xce12
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movss -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
callq 0xae70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x24(%rbp), %edx
movl $0x8, %esi
callq 0xc610
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0xc610
movq -0x8(%rbp), %rdi
callq 0xce80
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_set_resize
void xlink_set_resize(xlink_set *set, int capacity) {
  if (set->size == 0) {
    if (capacity < set->capacity) {
      set->capacity = capacity;
    }
    else {
      set->table = xlink_realloc(set->table, capacity*sizeof(int));
      memset(set->table, 0, capacity*sizeof(int));
      set->capacity = capacity;
    }
  }
  else {
    int *table;
    int i;
    table = xlink_malloc(capacity*sizeof(int));
    memset(table, 0, capacity*sizeof(int));
    i = set->capacity;
    set->capacity = capacity;
    while (i-- > 0) {
      int entry_index;
      entry_index = set->table[i];
      while (entry_index != 0) {
        xlink_entry *entry;
        int down;
        int index;
        entry = xlink_list_get(&set->entries, entry_index - 1);
        down = entry->down;
        index = xlink_set_index(set, entry->hash);
        entry->down = table[index];
        table[index] = entry_index;
        entry_index = down;
      }
    }
    free(set->table);
    set->table = table;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xcf87
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xcf41
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0xcf82
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0xc(%rbp), %rsi
shlq $0x2, %rsi
callq 0xaed0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0xc(%rbp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x20b0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0xd060
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0xae70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x20b0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0xd047
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xd042
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x20(%rbp), %esi
subl $0x1, %esi
callq 0xc870
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xd070
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xcfe1
jmp 0xcfbf
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_set_add
void *xlink_set_add(xlink_set *set, const void *value) {
  xlink_entry entry;
  int index;
  if (set->size + 1 > set->capacity*set->load) {
    xlink_set_resize(set, set->capacity << 1);
  }
  entry.hash = set->hash_code(value);
  index = xlink_set_index(set, entry.hash);
  entry.down = set->table[index];
  XLINK_ERROR(
   xlink_list_length(&set->entries) != xlink_list_length(&set->values),
   ("Invalid xlink_set state, entries length = %i but values length = %i\n",
   xlink_list_length(&set->entries), xlink_list_length(&set->values)));
  xlink_list_add(&set->entries, &entry);
  xlink_list_add(&set->values, value);
  set->table[index] = xlink_list_length(&set->entries);
  set->size++;
  return xlink_list_get(&set->values, set->table[index] - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl 0x10(%rax), %xmm1
movq -0x8(%rbp), %rax
mulss 0x14(%rax), %xmm1
ucomiss %xmm1, %xmm0
jbe 0xd0d7
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
shll %esi
callq 0xcf10
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xd070
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xc6a0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0xc6a0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
je 0xd168
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xc6a0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0xc6a0
movl -0x24(%rbp), %esi
movl %eax, %edx
leaq 0x3372(%rip), %rdi      # 0x104c9
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xd16a
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
leaq -0x18(%rbp), %rsi
callq 0xc950
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
callq 0xc950
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xc6a0
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
subl $0x1, %esi
callq 0xc870
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_set_get
void *xlink_set_get(xlink_set *set, void *key) {
  unsigned int hash;
  int index;
  hash = set->hash_code(key);
  index = set->table[xlink_set_index(set, hash)];
  while (index != 0) {
    xlink_entry *entry;
    void *value;
    entry = xlink_list_get(&set->entries, index - 1);
    value = xlink_list_get(&set->values, index - 1);
    if (set->equals == NULL ||
     (entry->hash == hash && set->equals(key, value))) {
      return value;
    }
    index = entry->down;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xd070
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xd56e
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movl -0x20(%rbp), %esi
subl $0x1, %esi
callq 0xc870
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movl -0x20(%rbp), %esi
subl $0x1, %esi
callq 0xc870
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd558
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0xd562
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0xd562
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd576
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0xd4f7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: test_check_EOF
static int test_check_EOF(char *name, int expected) {
    BGZF *bgz = try_bgzf_open(name, "r", __func__);
    int eof;
    if (!bgz) return -1;
    eof = bgzf_check_EOF(bgz);
    if (eof != expected) {
        fprintf(stderr, "%s : Unexpected result %d from bgzf_check_EOF on %s; "
                "expected %d\n",
                __func__, eof, name, expected);
        bgzf_close(bgz);
        return -1;
    }

    return try_bgzf_close(&bgz, name, __func__, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xe8157(%rip), %rsi     # 0xee581
leaq 0xe3c2f(%rip), %rdx     # 0xea060
callq 0x8b70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x644a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x64b3
movq -0x20(%rbp), %rdi
callq 0xe4f0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x649a
movq 0x101b7b(%rip), %rax    # 0x107fe0
movq (%rax), %rdi
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %r8
movl -0x14(%rbp), %r9d
leaq 0xe3bf5(%rip), %rsi     # 0xea06f
leaq 0xe3bdf(%rip), %rdx     # 0xea060
movb $0x0, %al
callq 0x46d0
movq -0x20(%rbp), %rdi
callq 0xe0e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x64b3
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq 0xe3bb7(%rip), %rdx     # 0xea060
xorl %ecx, %ecx
callq 0x8c10
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/test/test_bgzf.c
// Function: test_read
static int test_read(Files *f) {
    BGZF* bgz;
    ssize_t bg_got, f_got;
    unsigned char bg_buf[BUFSZ], f_buf[BUFSZ];

    errno = 0;
    bgz = try_bgzf_open(f->src_bgzf, "r", __func__);
    if (!bgz) return -1;

    do {
        bg_got = try_bgzf_read(bgz, bg_buf, BUFSZ, f->src_bgzf, __func__);
        if (bg_got < 0) goto fail;

        f_got = try_fread(f->f_plain, f_buf, BUFSZ, __func__, f->src_plain);
        if (f_got < 0) goto fail;

        if (compare_buffers(f_buf, bg_buf, f_got, bg_got,
                            f->src_plain, f->src_bgzf, __func__) != 0) {
            goto fail;
        }
    } while (bg_got > 0 && f_got > 0);

    if (try_bgzf_close(&bgz, f->src_bgzf, __func__, 0) != 0) return -1;
    if (try_fseek_start(f->f_plain, f->src_plain, __func__) != 0) return -1;

    return 0;

 fail:
    if (bgz) bgzf_close(bgz);
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10040, %rsp          # imm = 0x10040
movq %rdi, -0x10(%rbp)
callq 0x4050
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe8098(%rip), %rsi     # 0xee581
leaq 0xe3c49(%rip), %rdx     # 0xea139
callq 0x8b70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x650c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6656
jmp 0x650e
movq -0x18(%rbp), %rdi
leaq -0x8030(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x8000, %edx           # imm = 0x8000
leaq 0xe3c0c(%rip), %r8      # 0xea139
callq 0x8d30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x6542
jmp 0x663f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x10030(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %r8
movl $0x8000, %edx           # imm = 0x8000
leaq 0xe3bd5(%rip), %rcx     # 0xea139
callq 0x8dc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x6579
jmp 0x663f
leaq -0x10030(%rbp), %rdi
leaq -0x8030(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r9
leaq 0xe3b94(%rip), %rax     # 0xea139
movq %rax, (%rsp)
callq 0x8e70
cmpl $0x0, %eax
je 0x65b8
jmp 0x663f
jmp 0x65ba
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x10031(%rbp)
jle 0x65d7
cmpq $0x0, -0x28(%rbp)
setg %al
movb %al, -0x10031(%rbp)
movb -0x10031(%rbp), %al
testb $0x1, %al
jne 0x650e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x18(%rbp), %rdi
leaq 0xe3b41(%rip), %rdx     # 0xea139
xorl %ecx, %ecx
callq 0x8c10
cmpl $0x0, %eax
je 0x660d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6656
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xe3b16(%rip), %rdx     # 0xea139
callq 0x8f50
cmpl $0x0, %eax
je 0x6636
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6656
movl $0x0, -0x4(%rbp)
jmp 0x6656
cmpq $0x0, -0x18(%rbp)
je 0x664f
movq -0x18(%rbp), %rdi
callq 0xe0e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10040, %rsp          # imm = 0x10040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: cleanup
static void cleanup(Files *f, int retval) {
    /* Remove temp files if successful.  If not, leave them for inspection */
    if (retval == EXIT_SUCCESS) {
        unlink(f->tmp_bgzf);
        unlink(f->tmp_idx);
    }
    if (f->f_plain) fclose(f->f_plain);
    if (f->f_bgzf)  fclose(f->f_bgzf);
    if (f->f_idx)   fclose(f->f_idx);
    free(f->src_plain);
    free((unsigned char *) f->text);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x8a7f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x41e0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x41e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x8a97
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4490
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x8aaf
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x4490
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x8ac7
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x4490
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4590
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x4590
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_fopen
static FILE * try_fopen(const char *name, const char *mode) {
    FILE *f = fopen(name, mode);
    if (!f) {
        fprintf(stderr, "Couldn't open %s : %s\n", name, strerror(errno));
        return NULL;
    }
    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4580
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8b5d
movq 0xff4c1(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0xe14fd(%rip), %rsi     # 0xea049
movb $0x0, %al
callq 0x46d0
movq $0x0, -0x8(%rbp)
jmp 0x8b65
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_open
static BGZF * try_bgzf_open(const char *name, const char *mode,
                            const char *func) {
    BGZF * bgz = bgzf_open(name, mode);
    if (!bgz) {
        fprintf(stderr, "%s : Couldn't bgzf_open %s with mode %s : %s\n",
                func, name, mode, strerror(errno));
        return NULL;
    }
    return bgz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9da0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8bf9
movq 0xff43d(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movq %rax, %r9
leaq 0xe14c9(%rip), %rsi     # 0xea0b1
movb $0x0, %al
callq 0x46d0
movq $0x0, -0x8(%rbp)
jmp 0x8c01
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_close
static int try_bgzf_close(BGZF **bgz, const char *name, const char *func, int expected_fail) {
    BGZF *to_close = *bgz;
    *bgz = NULL;
    if (bgzf_close(to_close) != 0) {
        if (!expected_fail)
            fprintf(stderr, "%s : bgzf_close failed on %s%s%s\n",
                    func, name,
                    errno ? " : " : "",
                    errno ? strerror(errno) : "");
        return -1;
    } else if (expected_fail) {
        fprintf(stderr, "%s : bgzf_close worked on %s, but expected failure\n",
                func, name);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rdi
callq 0xe0e0
cmpl $0x0, %eax
je 0x8ceb
cmpl $0x0, -0x24(%rbp)
jne 0x8ce2
movq 0xff380(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x4050
movl (%rax), %edx
leaq 0xe2f10(%rip), %rax     # 0xebb95
leaq 0xe1475(%rip), %rcx     # 0xea101
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x38(%rbp)
callq 0x4050
cmpl $0x0, (%rax)
je 0x8cb3
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq %rax, -0x58(%rbp)
jmp 0x8cc0
leaq 0xe2edb(%rip), %rax     # 0xebb95
movq %rax, -0x58(%rbp)
jmp 0x8cc0
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %r9
leaq 0xe1404(%rip), %rsi     # 0xea0df
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8d1a
cmpl $0x0, -0x24(%rbp)
je 0x8d11
movq 0xff2e8(%rip), %rax     # 0x107fe0
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0xe13fb(%rip), %rsi     # 0xea105
movb $0x0, %al
callq 0x46d0
jmp 0x8d13
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_read
static ssize_t try_bgzf_read(BGZF *fp, void *data, size_t length,
                             const char *name, const char *func) {
    ssize_t got = bgzf_read_small(fp, data, length);
    if (got < 0) {
        fprintf(stderr, "%s : Error from bgzf_read %s : %s\n",
                func, name, strerror(errno));
    }
    return got;
}

// 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 -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8fe0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x8daf
movq 0xff271(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq %rax, %r8
leaq 0xe139b(%rip), %rsi     # 0xea143
movb $0x0, %al
callq 0x46d0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_fread
static ssize_t try_fread(FILE *in, void *buf, size_t len,
                         const char *func, const char *fname) {
    size_t got = fread(buf, 1, len, in);
    if (got == 0 && ferror(in)) {
        fprintf(stderr, "%s : Error reading from %s : %s\n",
                func, fname, strerror(errno));
        return -1;
    }
    return got;
}

// 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 -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x4770
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x8e5c
movq -0x10(%rbp), %rdi
callq 0x4950
cmpl $0x0, %eax
je 0x8e5c
movq 0xff1ce(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq %rax, %r8
leaq 0xe131b(%rip), %rsi     # 0xea166
movb $0x0, %al
callq 0x46d0
movq $-0x1, -0x8(%rbp)
jmp 0x8e64
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: compare_buffers
static int compare_buffers(const unsigned char *b1, const unsigned char *b2,
                           size_t l1, size_t l2,
                           const char *name1, const char *name2,
                           const char *func) {
    if (l1 != l2) {
        fprintf(stderr, "%s : EOF on %s\n", func, l1 < l2 ? name1 : name2);
        return -1;
    }
    if (memcmp(b1, b2, l1) != 0) {
        fprintf(stderr, "%s : difference between %s and %s\n",
                func, name1, name2);
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x8ef3
movq 0xff13b(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x8ec8
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x8ed0
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rcx
leaq 0xe12a4(%rip), %rsi     # 0xea187
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8f3d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x41b0
cmpl $0x0, %eax
je 0x8f36
movq 0xff0d0(%rip), %rax     # 0x107fe0
movq (%rax), %rdi
movq 0x10(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq 0xe1271(%rip), %rsi     # 0xea197
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8f3d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_fseek_start
static int try_fseek_start(FILE *f, const char *name, const char *func) {
    if (0 != fseek(f, 0, SEEK_SET)) {
        fprintf(stderr, "%s : Couldn't seek on %s : %s\n",
                func, name, strerror(errno));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4510
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x8fcb
movq 0xff05e(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq %rax, %r8
leaq 0xe11ff(%rip), %rsi     # 0xea1ba
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8fd2
movl $0x0, -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/test/test_bgzf.c
// Function: try_bgzf_dopen
static BGZF * try_bgzf_dopen(const char *name, const char *mode,
                             const char *func) {
    BGZF *bgz = NULL;
    int fd = open(name, hfile_oflags(mode), 0666);
    if (fd < 0) {
        fprintf(stderr, "%s : Failed to open %s with mode %s : %s\n",
                func, name, mode, strerror(errno));
        return NULL;
    }

    bgz = bgzf_dopen(fd, mode);
    if (!bgz) {
        fprintf(stderr, "%s : bgzf_dopen failed on %s mode %s : %s\n",
                func, name, mode, strerror(errno));
        close(fd);
        return NULL;
    }

    return bgz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12890
movq -0x38(%rbp), %rdi
movl %eax, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x4310
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x912b
movq 0xfef0e(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
movq %rax, %r9
leaq 0xe1124(%rip), %rsi     # 0xea23b
movb $0x0, %al
callq 0x46d0
movq $0x0, -0x8(%rbp)
jmp 0x91af
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xa440
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x91a7
movq 0xfee97(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %r8
movq %rax, %r9
leaq 0xe10d7(%rip), %rsi     # 0xea265
movb $0x0, %al
callq 0x46d0
movl -0x2c(%rbp), %edi
callq 0x49b0
movq $0x0, -0x8(%rbp)
jmp 0x91af
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_hopen
static BGZF * try_bgzf_hopen(const char *name, const char *mode,
                          const char *func) {
    hFILE *hfp = hopen(name, mode);
    BGZF *bgz = NULL;

    if (!hfp) {
        fprintf(stderr, "%s : hopen failed on %s mode %s : %s\n",
                func, name, mode, strerror(errno));
        return NULL;
    }

    bgz = bgzf_hopen(hfp, mode);
    if (!bgz) {
        fprintf(stderr, "%s : bgzf_hopen failed on %s mode %s : %s\n",
                func, name, mode, strerror(errno));
        hclose_abruptly(hfp);
        return NULL;
    }

    return bgz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq 0x135c0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9256
movq 0xfede3(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
movq %rax, %r9
leaq 0xe104e(%rip), %rsi     # 0xea290
movb $0x0, %al
callq 0x46d0
movq $0x0, -0x8(%rbp)
jmp 0x92dc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa590
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x92d4
movq 0xfed6b(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r8
movq %rax, %r9
leaq 0xe0ffc(%rip), %rsi     # 0xea2b6
movb $0x0, %al
callq 0x46d0
movq -0x28(%rbp), %rdi
callq 0x126e0
movq $0x0, -0x8(%rbp)
jmp 0x92dc
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_mt
static int try_bgzf_mt(BGZF *bgz, int nthreads, const char *func) {
    if (bgzf_mt(bgz, nthreads, 64) != 0) {
        fprintf(stderr, "%s : Error from bgzf_mt : %s\n",
                func, strerror(errno));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x40, %edx
callq 0xd480
cmpl $0x0, %eax
je 0x935d
movq 0xfecc0(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0xe0f94(%rip), %rsi     # 0xea2e1
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9364
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_write
static ssize_t try_bgzf_write(BGZF *fp, const void *data, size_t length,
                              const char *name, const char *func) {
    ssize_t put = bgzf_write_small(fp, data, length);
    if (put < (ssize_t) length) {
        fprintf(stderr, "%s : %s %s : %s\n",
                func, put < 0 ? "Error writing to" : "Short write on",
                name, strerror(errno));
        return -1;
    }

    return put;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x94a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x941e
movq 0xfec2e(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdx
leaq 0xe0f55(%rip), %rax     # 0xea321
leaq 0xe0f3d(%rip), %rcx     # 0xea310
cmpq $0x0, %rdx
cmovlq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
movq %rax, %r9
leaq 0xe0ef2(%rip), %rsi     # 0xea2ff
movb $0x0, %al
callq 0x46d0
movq $-0x1, -0x8(%rbp)
jmp 0x9426
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_compression
static int try_bgzf_compression(BGZF *fp, int expect,
                                const char *name, const char *func) {
    int res = bgzf_compression(fp);
    if (res != expect) {
        fprintf(stderr,
                "%s : Unexpected result %d from bgzf_compression on %s; "
                "expected %d\n",
                func, res, name, expect);
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xeaf0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x948b
movq 0xfeb7e(%rip), %rax     # 0x107fe0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %r8
movl -0x14(%rbp), %r9d
leaq 0xe0eb5(%rip), %rsi     # 0xea330
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9492
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_index_load
static int try_bgzf_index_load(BGZF *fp, const char *bname, const char *suffix,
                               const char *func) {
    if (bgzf_index_load(fp, bname, suffix) != 0) {
        fprintf(stderr, "%s : Couldn't bgzf_index_load %s%s : %s\n",
                func, bname, suffix ? suffix : "", strerror(errno));
        return -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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xf5e0
cmpl $0x0, %eax
je 0x95e8
movq 0xfea6b(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x959d
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x95aa
leaq 0xe25f1(%rip), %rax     # 0xebb95
movq %rax, -0x48(%rbp)
jmp 0x95aa
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %r8
movq %rax, %r9
leaq 0xe0dc0(%rip), %rsi     # 0xea398
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x95ef
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_index_dump
static int try_bgzf_index_dump(BGZF *fp, const char *bname, const char *suffix,
                               const char *func) {
    if (bgzf_index_dump(fp, bname, suffix) != 0) {
        fprintf(stderr, "%s : Couldn't bgzf_index_dump %s%s : %s\n",
                func, bname, suffix ? suffix : "", strerror(errno));
        return -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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xf170
cmpl $0x0, %eax
je 0x96a8
movq 0xfe9ab(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x965d
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x966a
leaq 0xe2531(%rip), %rax     # 0xebb95
movq %rax, -0x48(%rbp)
jmp 0x966a
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %r8
movq %rax, %r9
leaq 0xe0d29(%rip), %rsi     # 0xea3c1
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x96af
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_fclose
static int try_fclose(FILE **file, const char *name, const char *func) {
    FILE *to_close = *file;
    *file = NULL;
    if (fclose(to_close) != 0) {
        fprintf(stderr, "%s : Error on closing %s : %s\n",
                func, name, strerror(errno));
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rdi
callq 0x4490
cmpl $0x0, %eax
je 0x9748
movq 0xfe8e1(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rax, %r8
leaq 0xe0cb2(%rip), %rsi     # 0xea3ea
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x974f
movl $0x0, -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/test/test_bgzf.c
// Function: try_bgzf_index_build_init
static int try_bgzf_index_build_init(BGZF *bgz,
                                     const char *name, const char *func) {
    if (bgzf_index_build_init(bgz) != 0) {
        fprintf(stderr, "%s : Error from bgzf_index_build_init on %s : %s\n",
                func, name, strerror(errno));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xef10
cmpl $0x0, %eax
je 0x97d2
movq 0xfe857(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq %rax, %r8
leaq 0xe0c5d(%rip), %rsi     # 0xea41f
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x97d9
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/test/test_bgzf.c
// Function: try_bgzf_useek
static int try_bgzf_useek(BGZF *fp, long uoffset, int where,
                          const char *name, const char *func) {
    if (bgzf_useek(fp, uoffset, where) < 0) {
        fprintf(stderr, "%s : Error from bgzf_useek(%s, %ld, %d) : %s\n",
                func, name, uoffset, where, strerror(errno));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xf730
cmpl $0x0, %eax
jge 0x9887
movq 0xfe7b9(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
movl -0x34(%rbp), %r9d
leaq 0xe0bde(%rip), %rsi     # 0xea451
movq %rax, (%rsp)
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x988e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_getc
static int try_bgzf_getc(BGZF *fp, size_t pos, int expected,
                         const char *name, const char *func) {
    int c = bgzf_getc(fp);
    if (c != expected) {
        fprintf(stderr,
                "%s : Unexpected value (%d) from bgzf_getc on %s pos %zu; "
                "expected %d\n",
                func, c, name, pos, expected);
        return -1;
    }
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xeb40
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x9905
movq 0xfe70a(%rip), %rax     # 0x107fe0
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x18(%rbp), %r9
movl -0x1c(%rbp), %eax
leaq 0xe0b8d(%rip), %rsi     # 0xea47f
movl %eax, (%rsp)
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x990b
movl -0x34(%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/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_tell
static int64_t try_bgzf_tell(BGZF *fp, const char *name, const char *func) {
    int64_t told = bgzf_tell(fp);
    if (told < 0) {
        fprintf(stderr, "%s : %s %s : %s\n",
                func, "Error telling in",
                name, strerror(errno));
        return -1;
    }

    return told;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x10, %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x99b6
movq 0xfe67b(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %r8
movq %rax, %r9
leaq 0xe0961(%rip), %rsi     # 0xea2ff
leaq 0xe0b34(%rip), %rcx     # 0xea4d9
movb $0x0, %al
callq 0x46d0
movq $-0x1, -0x8(%rbp)
jmp 0x99be
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_seek
static int try_bgzf_seek(BGZF *fp, int64_t pos, int whence,
                          const char *name, const char *func) {
    if (bgzf_seek(fp, pos, whence) < 0) {
        fprintf(stderr, "%s : Error from bgzf_seek(%s, %" PRId64 ", %d) : %s\n",
                func, name, pos, whence, strerror(errno));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xe790
cmpq $0x0, %rax
jge 0x9a68
movq 0xfe5d8(%rip), %rax     # 0x107fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
movl -0x34(%rbp), %r9d
leaq 0xe0a96(%rip), %rsi     # 0xea4ea
movq %rax, (%rsp)
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a6f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_tell_expect
static int64_t try_bgzf_tell_expect(BGZF *fp, int64_t expected, const char *name, const char *func) {
    int64_t told = try_bgzf_tell(fp, name, func);
    if (told != expected) {
        fprintf(stderr, "%s : Unexpected value (%" PRId64 ") from bgzf_tell on %s; "
                "expected %" PRId64 "\n",
                func, told, name, expected);
        return -1;
    }
    return told;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9920
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x9ae9
movq 0xfe522(%rip), %rax     # 0x107fe0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x18(%rbp), %r9
leaq 0xe0a3f(%rip), %rsi     # 0xea517
movb $0x0, %al
callq 0x46d0
movq $-0x1, -0x8(%rbp)
jmp 0x9af1
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)