LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr.c
// Function: gt_cstr_rep
void gt_cstr_rep(char *cstr, char f, char t)
{
  char *cc;
  gt_assert(cstr);
  cc = cstr;
  while (*cc) {
    if (*cc == f)
      *cc = t;
    cc++;
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7238a
movb (%rdi), %al
testb %al, %al
je 0x72388
incq %rdi
cmpb %sil, %al
jne 0x7237f
movb %dl, -0x1(%rdi)
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x72377
popq %rax
retq
callq 0x1a01a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr.c
// Function: gt_cstr_show
void gt_cstr_show(const char *cstr, GtUword length, FILE *fp)
{
  GtUword i;
  gt_assert(cstr && fp);
  for (i = 0; i < length; i++)
    gt_xfputc(cstr[i], fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x723d3
movq %rdx, %rbx
testq %rdx, %rdx
je 0x723d3
movq %rsi, %r14
testq %rsi, %rsi
je 0x723c7
movq %rdi, %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
movq %rbx, %rsi
callq 0x3dc12
incq %r12
cmpq %r12, %r14
jne 0x723b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1a051
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr.c
// Function: gt_cstr_length_up_to_char
GtUword gt_cstr_length_up_to_char(const char *cstr, char c)
{
  char *suffix;
  gt_assert(cstr);
  suffix = strchr(cstr, c);
  if (suffix)
    return suffix - cstr;
  return strlen(cstr);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x723fd
movq %rdi, %rbx
movsbl %sil, %esi
callq 0xb210
testq %rax, %rax
je 0x723f4
subq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0xb260
callq 0x1a088
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr.c
// Function: gt_cstr_rtrim
char* gt_cstr_rtrim(char *cstr, char remove)
{
  char *tmp;
  gt_assert(cstr);
  for (tmp = cstr + strlen(cstr) - 1; tmp >= cstr && *tmp == remove; --tmp);
  *(tmp+1) = '\0';
  return cstr;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7243a
movl %esi, %ebp
movq %rdi, %rbx
callq 0xb260
leaq (%rax,%rbx), %rcx
decq %rcx
movq %rcx, %rax
cmpq %rbx, %rcx
jb 0x7242c
leaq -0x1(%rax), %rcx
cmpb %bpl, (%rax)
je 0x7241b
movb $0x0, 0x1(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1a0bf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr.c
// Function: gt_cstr_unit_test
int gt_cstr_unit_test(GtError *err)
{
  int had_err = 0;
  char **res;
  const char *foo = "foo  bar baz";
  gt_error_check(err);

  res = gt_cstr_split(foo, ' ');
  gt_ensure(strcmp(res[0], "foo") == 0);
  gt_ensure(strcmp(res[1], "") == 0);
  gt_ensure(strcmp(res[2], "bar") == 0);
  gt_ensure(strcmp(res[3], "baz") == 0);
  gt_ensure(res[4] == NULL);
  gt_cstr_array_delete(res);

  res = gt_cstr_split("", ' ');
  gt_ensure(res[0] == NULL);
  gt_cstr_array_delete(res);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7245e
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x72614
leaq 0x7de22(%rip), %rdi     # 0xf0287
movl $0x20, %esi
callq 0x721cc
movq %rax, %r14
movq (%rax), %rdi
leaq 0x7f7b5(%rip), %rsi     # 0xf1c31
callq 0xb890
testl %eax, %eax
je 0x724b2
leaq 0x70ced(%rip), %rsi     # 0xe3179
leaq 0x7de13(%rip), %rdx     # 0xf02a6
leaq 0x7ddfa(%rip), %rcx     # 0xf0294
leaq 0x7dd63(%rip), %r8      # 0xf0204
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x7c, %r9d
jmp 0x72597
movq 0x8(%r14), %rax
cmpb $0x0, (%rax)
je 0x724e8
leaq 0x70cb7(%rip), %rsi     # 0xe3179
leaq 0x7ddf8(%rip), %rdx     # 0xf02c1
leaq 0x7ddc4(%rip), %rcx     # 0xf0294
leaq 0x7dd2d(%rip), %r8      # 0xf0204
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x7d, %r9d
jmp 0x72597
movq 0x10(%r14), %rdi
leaq 0x7edd4(%rip), %rsi     # 0xf12c7
callq 0xb890
testl %eax, %eax
je 0x72526
leaq 0x70c76(%rip), %rsi     # 0xe3179
leaq 0x7ddcf(%rip), %rdx     # 0xf02d9
leaq 0x7dd83(%rip), %rcx     # 0xf0294
leaq 0x7dcec(%rip), %r8      # 0xf0204
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x7e, %r9d
jmp 0x72597
movq 0x18(%r14), %rdi
leaq 0x7dd5f(%rip), %rsi     # 0xf0290
callq 0xb890
testl %eax, %eax
je 0x72564
leaq 0x70c38(%rip), %rsi     # 0xe3179
leaq 0x7ddac(%rip), %rdx     # 0xf02f4
leaq 0x7dd45(%rip), %rcx     # 0xf0294
leaq 0x7dcae(%rip), %r8      # 0xf0204
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x7f, %r9d
jmp 0x72597
cmpq $0x0, 0x20(%r14)
je 0x7260f
leaq 0x70c03(%rip), %rsi     # 0xe3179
leaq 0x7dd92(%rip), %rdx     # 0xf030f
leaq 0x7dd10(%rip), %rcx     # 0xf0294
leaq 0x7dc79(%rip), %r8      # 0xf0204
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x80, %r9d
xorl %eax, %eax
callq 0x3559f
movq %r14, %rdi
callq 0x728c2
leaq 0x7c5d2(%rip), %rdi     # 0xeeb7f
movl $0x20, %esi
callq 0x721cc
movq %rax, %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r15b, %r15b
je 0x725fa
cmpq $0x0, (%r14)
je 0x725f8
leaq 0x70ba8(%rip), %rsi     # 0xe3179
leaq 0x7dd46(%rip), %rdx     # 0xf031e
leaq 0x7dcb5(%rip), %rcx     # 0xf0294
leaq 0x7dc1e(%rip), %r8      # 0xf0204
movq %rbx, %rdi
movl $0x84, %r9d
xorl %eax, %eax
callq 0x3559f
jmp 0x725fa
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x728c2
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0x7259e
callq 0x1a0f6
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_array.c
// Function: gt_cstr_array_dup
char** gt_cstr_array_dup(const char **cstr_array)
{
  GtUword i, size = 0;
  char **copy;
  gt_assert(cstr_array);
  while (cstr_array[size++]);
  copy = gt_malloc(size * sizeof *copy);
  for (i = 0; i < size - 1; i++)
    copy[i] = gt_cstr_dup(cstr_array[i]);
  copy[size-1] = NULL;
  return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x72691
movq %rdi, %rbx
movl $0x1, %r12d
xorl %r14d, %r14d
decq %r12
cmpq $0x0, (%rbx,%r14)
leaq 0x8(%r14), %r14
jne 0x72636
leaq 0x7dcff(%rip), %rsi     # 0xf034a
movq %r14, %rdi
movl $0x1e, %edx
callq 0x35ee2
movq %rax, %r15
testq %r12, %r12
je 0x7267b
negq %r12
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rdi
callq 0x722dc
movq %rax, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x72666
movq $0x0, -0x8(%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1a12d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_array.c
// Function: gt_cstr_array_prefix_first
char** gt_cstr_array_prefix_first(const char **cstr_array, const char *p)
{
  GtUword i, a_len, f_len;
  char **a;
  gt_assert(cstr_array && p);
  a_len = gt_cstr_array_size(cstr_array);
  a = gt_malloc(sizeof (char*) * (a_len + 1));
  f_len = strlen(p) + strlen(cstr_array[0]) + 2; /* blank + '\0' */
  a[0] = gt_malloc(sizeof (char) * f_len);
  (void) snprintf(a[0], f_len, "%s %s", p, cstr_array[0]);
  for (i = 1; i < a_len; i++)
    a[i] = gt_cstr_dup(cstr_array[i]);
  a[a_len] = NULL;
  return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x72772
movq %rsi, %r15
testq %rsi, %rsi
je 0x72772
movq %rdi, %rbx
movl $0x1, %r13d
xorl %r14d, %r14d
decq %r13
cmpq $0x0, (%rbx,%r14)
leaq 0x8(%r14), %r14
jne 0x726c2
leaq 0x7dc73(%rip), %rsi     # 0xf034a
movq %r14, %rdi
movl $0x2b, %edx
callq 0x35ee2
movq %rax, %r12
movq %r15, %rdi
callq 0xb260
movq %rax, %rbp
movq (%rbx), %rdi
callq 0xb260
addq %rax, %rbp
addq $0x2, %rbp
movq %rbp, %rdi
leaq 0x7dc3f(%rip), %rsi     # 0xf034a
movl $0x2d, %edx
callq 0x35ee2
movq %rax, (%r12)
movq (%rbx), %r8
leaq 0x6fa66(%rip), %rdx     # 0xe2189
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0xba10
negq %r13
cmpq $0x2, %r13
jb 0x72757
movl $0x1, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x722dc
movq %rax, (%r12,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x72742
movq $0x0, -0x8(%r12,%r14)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a164
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_array.c
// Function: gt_cstr_array_preprend
char** gt_cstr_array_preprend(const char **cstr_array, const char *p)
{
  GtUword i, a_len;
  char **a;
  gt_assert(cstr_array && p);
  a_len = gt_cstr_array_size(cstr_array);
  a = gt_malloc(sizeof (char*) * (a_len + 2));
  a[0] = gt_cstr_dup(p);
  for (i = 0; i < a_len; i++)
    a[i+1] = gt_cstr_dup(cstr_array[i]);
  a[a_len+1] = NULL;
  return a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x7281d
movq %rsi, %r15
testq %rsi, %rsi
je 0x7281d
movq %rdi, %rbx
movl $0x1, %r13d
movl $0x8, %r14d
decq %r13
cmpq $0x0, -0x8(%rbx,%r14)
leaq 0x8(%r14), %r14
jne 0x727b4
leaq 0x7db80(%rip), %rsi     # 0xf034a
movq %r14, %rdi
movl $0x3b, %edx
callq 0x35ee2
movq %rax, %r12
movq %r15, %rdi
callq 0x722dc
movq %rax, (%r12)
testq %r13, %r13
je 0x72807
negq %r13
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x722dc
movq %rax, 0x8(%r12,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x727f1
movq $0x0, -0x8(%r12,%r14)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1a19b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_array.c
// Function: gt_cstr_array_show
void gt_cstr_array_show(char **cstr_array, FILE *fp)
{
  GtUword i = 0;
  while (cstr_array[i]) {
    if (i)
      gt_xfputc(' ', fp);
    gt_xfputs(cstr_array[i], fp);
    i++;
  }
  gt_xfputc('\n', fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, (%rdi)
je 0x72860
movq %rdi, %r14
xorl %r15d, %r15d
testq %r15, %r15
je 0x72848
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3dc12
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x3dc24
cmpq $0x0, 0x8(%r14,%r15,8)
leaq 0x1(%r15), %r15
jne 0x72836
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3dc12
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_array.c
// Function: gt_cstr_array_show_genfile
void gt_cstr_array_show_genfile(const char **cstr_array, GtFile *fp)
{
  GtUword i = 0;
  while (cstr_array[i]) {
    if (i)
      gt_file_xfputc(' ', fp);
    gt_file_xfputs(cstr_array[i], fp);
    i++;
  }
  gt_file_xfputc('\n', fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, (%rdi)
je 0x728b0
movq %rdi, %r14
xorl %r15d, %r15d
testq %r15, %r15
je 0x72898
movl $0x20, %edi
movq %rbx, %rsi
callq 0x759ff
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x75a44
cmpq $0x0, 0x8(%r14,%r15,8)
leaq 0x1(%r15), %r15
jne 0x72886
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x759ff
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_array.c
// Function: gt_cstr_array_delete
void gt_cstr_array_delete(char **cstr_array)
{
  GtUword i = 0;
  if (!cstr_array) return;
  while (cstr_array[i])
    gt_free(cstr_array[i++]);
  gt_free(cstr_array);
}

// Assembly:
testq %rdi, %rdi
je 0x72914
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x728fb
leaq 0x8(%rbx), %r15
leaq 0x7da68(%rip), %r14     # 0xf034a
movq %r14, %rsi
movl $0x68, %edx
callq 0x362a0
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x728e2
leaq 0x7da48(%rip), %rsi     # 0xf034a
movq %rbx, %rdi
movl $0x69, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x362a0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_table.c
// Function: gt_cstr_table_add
void gt_cstr_table_add(GtCstrTable *table, const char *cstr)
{
  char *dup;
  GT_UNUSED int rval;
  gt_assert(table && cstr);
  gt_assert(!gt_cstr_table_get(table, cstr));
  dup = gt_cstr_dup(cstr);
  rval = gt_hashtable_add(table->strings, &dup);
  gt_assert(rval == 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x729ce
movq %rsi, %r14
testq %rsi, %rsi
je 0x729ce
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, (%rsi)
movq (%rdi), %rdi
callq 0x77906
testq %rax, %rax
je 0x729ab
cmpq $0x0, (%rax)
jne 0x729d8
movq %r14, %rdi
callq 0x722dc
movq %rsp, %rsi
movq %rax, (%rsi)
movq (%rbx), %rdi
callq 0x7799a
cmpl $0x1, %eax
jne 0x729d3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a1d2
callq 0x1a240
callq 0x1a209
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_table.c
// Function: gt_cstr_table_get
const char* gt_cstr_table_get(const GtCstrTable *table, const char *cstr)
{
  const char **entry;
  gt_assert(table && cstr);
  entry = gt_hashtable_get(table->strings, &cstr);
  return entry ? *entry : NULL;
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
testq %rdi, %rdi
je 0x72a05
testq %rsi, %rsi
je 0x72a05
movq (%rdi), %rdi
movq %rsp, %rsi
callq 0x77906
testq %rax, %rax
je 0x72a01
movq (%rax), %rax
jmp 0x72a03
xorl %eax, %eax
popq %rcx
retq
callq 0x1a277
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_table.c
// Function: gt_cstr_table_get_all
GtStrArray* gt_cstr_table_get_all(const GtCstrTable *table)
{
  GT_UNUSED int had_err;
  GtStrArray *cstrs;
  gt_assert(table);
  cstrs = gt_str_array_new();
  had_err = gt_hashtable_foreach_ordered(table->strings, store_type, cstrs,
                                         gt_strcmpptr, NULL);
  gt_assert(!had_err);
  return cstrs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x72a49
movq %rdi, %r14
callq 0x3d23c
movq %rax, %rbx
movq (%r14), %rdi
leaq 0x2b(%rip), %rsi        # 0x72a53
leaq 0x10701(%rip), %rcx     # 0x83130
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x77e42
testl %eax, %eax
jne 0x72a4e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a2e5
callq 0x1a2ae
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_table.c
// Function: store_type
static enum iterator_op store_type(void *elem, void *data,
                                   GT_UNUSED GtError *err)
{
  GtStrArray *types = data;
  gt_error_check(err);
  gt_assert(elem && types);
  gt_str_array_add_cstr(types, *(char**) elem);
  return CONTINUE_ITERATION;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x72a6e
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x72a92
testq %r14, %r14
je 0x72a8d
testq %rbx, %rbx
je 0x72a8d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3d318
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a353
callq 0x1a31c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/cstr_table.c
// Function: gt_cstr_table_unit_test
int gt_cstr_table_unit_test(GtError *err)
{
  GtCstrTable *table;
  GtStrArray *sta;
  int had_err = 0;
  gt_error_check(err);
  table = gt_cstr_table_new();
  gt_ensure(!gt_cstr_table_get(table, "foo"));
  if (!had_err)
    gt_cstr_table_add(table, "foo");
  gt_ensure(!strcmp(gt_cstr_table_get(table, "foo"), "foo"));
  sta = gt_cstr_table_get_all(table);
  gt_ensure(gt_str_array_size(sta) == 1);
  gt_ensure(strcmp(gt_str_array_get(sta, 0), "foo") == 0);
  gt_str_array_delete(sta);
  gt_cstr_table_delete(table);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
testq %rdi, %rdi
je 0x72aef
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x72c97
leaq 0x7d8ac(%rip), %rsi     # 0xf03a2
movl $0x8, %edi
movl $0x27, %edx
callq 0x35ee2
movq %rax, %rbx
movups 0xdcc69(%rip), %xmm0    # 0x14f778
movups %xmm0, 0x20(%rsp)
movups 0xdcc4d(%rip), %xmm0    # 0x14f768
movups %xmm0, 0x10(%rsp)
movups 0xdcc31(%rip), %xmm0    # 0x14f758
movups %xmm0, (%rsp)
callq 0x777ac
movq %rax, (%rbx)
leaq 0x7f0f7(%rip), %rsi     # 0xf1c31
movq %rbx, %rdi
callq 0x729dd
testq %rax, %rax
je 0x72b70
leaq 0x7062b(%rip), %rsi     # 0xe3179
leaq 0x7d90c(%rip), %rdx     # 0xf0461
leaq 0x7d8ed(%rip), %rcx     # 0xf0449
leaq 0x7d83f(%rip), %r8      # 0xf03a2
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x68, %r9d
jmp 0x72bc7
leaq 0x7f0ba(%rip), %r15     # 0xf1c31
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7297e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x729dd
movq %rax, %rdi
movq %r15, %rsi
callq 0xb890
testl %eax, %eax
je 0x72c8f
leaq 0x705d2(%rip), %rsi     # 0xe3179
leaq 0x7d8d4(%rip), %rdx     # 0xf0482
leaq 0x7d894(%rip), %rcx     # 0xf0449
leaq 0x7d7e6(%rip), %r8      # 0xf03a2
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x6b, %r9d
xorl %eax, %eax
callq 0x3559f
movq %rbx, %rdi
callq 0x72a0a
movq %rax, %r15
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testb %bpl, %bpl
je 0x72c6f
movq %r15, %rdi
callq 0x3d560
cmpq $0x1, %rax
jne 0x72c3d
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
callq 0x3d3e2
leaq 0x7f027(%rip), %rsi     # 0xf1c31
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
je 0x72c6f
leaq 0x7055c(%rip), %rsi     # 0xe3179
leaq 0x7d8aa(%rip), %rdx     # 0xf04ce
leaq 0x7d81e(%rip), %rcx     # 0xf0449
leaq 0x7d770(%rip), %r8      # 0xf03a2
movq %r14, %rdi
movl $0x6e, %r9d
jmp 0x72c62
leaq 0x70535(%rip), %rsi     # 0xe3179
leaq 0x7d867(%rip), %rdx     # 0xf04b2
leaq 0x7d7f7(%rip), %rcx     # 0xf0449
leaq 0x7d749(%rip), %r8      # 0xf03a2
movq %r14, %rdi
movl $0x6d, %r9d
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0x3d573
movq %rbx, %rdi
callq 0x72c9c
movl %r12d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %bpl
jmp 0x72bce
callq 0x1a3f8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dlist.c
// Function: gt_dlist_new
GtDlist* gt_dlist_new(GtCompare cmp_func)
{
  GtDlist *dlist = gt_calloc(1, sizeof (GtDlist));
  if (cmp_func == NULL)
    dlist->cmp_func = NULL;
  else
    dlist->cmp_func = gt_dlist_cmp_wrapper;
  dlist->data = cmp_func;
  return dlist;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x7d845(%rip), %rdx     # 0xf0514
movl $0x1, %edi
movl $0x28, %esi
movl $0x31, %ecx
callq 0x3601f
testq %rbx, %rbx
leaq 0xd(%rip), %rcx         # 0x72cfa
cmoveq %rbx, %rcx
movq %rcx, (%rax)
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dlist.c
// Function: gt_dlist_new_with_data
GtDlist* gt_dlist_new_with_data(GtCompareWithData cmp_func, void *data)
{
  GtDlist *dlist = gt_calloc(1, sizeof (GtDlist));
  dlist->cmp_func = cmp_func;
  dlist->data = data;
  return dlist;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7d807(%rip), %rdx     # 0xf0514
movl $0x1, %edi
movl $0x28, %esi
movl $0x3c, %ecx
callq 0x3601f
movq %r14, (%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dlist.c
// Function: gt_dlist_find
GtDlistelem* gt_dlist_find(const GtDlist *dlist, void *new_data)
{
  GtDlistelem *dlistelem;
  void *old_data;
  gt_assert(dlist);
  for (dlistelem = gt_dlist_first(dlist); dlistelem != NULL;
       dlistelem = gt_dlistelem_next(dlistelem)) {
    old_data = gt_dlistelem_get_data(dlistelem);
    if (dlist->cmp_func && !dlist->cmp_func(old_data, new_data, dlist->data))
      return dlistelem;
    else if (old_data == new_data)
      return dlistelem;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x72da7
movq %rdi, %r15
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x72d96
movq %rsi, %r14
movq 0x10(%rbx), %r12
movq (%r15), %rax
testq %rax, %rax
je 0x72d88
movq 0x18(%r15), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
je 0x72d98
cmpq %r14, %r12
je 0x72d98
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x72d6c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1a49d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dlist.c
// Function: gt_dlist_remove
void gt_dlist_remove(GtDlist *dlist, GtDlistelem *dlistelem)
{
  gt_assert(dlist && dlistelem);
  gt_assert(!dlistelem->previous || dlistelem->previous->next == dlistelem);
  gt_assert(!dlistelem->next || dlistelem->next->previous == dlistelem);
  if (dlistelem->previous)
    dlistelem->previous->next = dlistelem->next;
  if (dlistelem->next)
    dlistelem->next->previous = dlistelem->previous;
  if (dlistelem == dlist->first)
    dlist->first = dlistelem->next;
  if (dlistelem == dlist->last)
    dlist->last = dlistelem->previous;
  dlist->size--;
  gt_free(dlistelem);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x72f94
testq %rsi, %rsi
je 0x72f94
movq (%rsi), %rax
testq %rax, %rax
je 0x72f3e
cmpq %rsi, 0x8(%rax)
jne 0x72f99
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x72f4c
cmpq %rsi, (%rcx)
jne 0x72f9e
testq %rax, %rax
je 0x72f55
movq %rcx, 0x8(%rax)
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x72f61
movq %rax, (%rcx)
cmpq %rsi, 0x8(%rdi)
jne 0x72f6b
movq %rcx, 0x8(%rdi)
cmpq %rsi, 0x10(%rdi)
jne 0x72f78
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
decq 0x20(%rdi)
leaq 0x7d591(%rip), %rax     # 0xf0514
movq %rsi, %rdi
movq %rax, %rsi
movl $0xad, %edx
popq %rax
jmp 0x362a0
callq 0x1a73d
callq 0x1a776
callq 0x1a7af
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dlist.c
// Function: gt_dlist_example
int gt_dlist_example(GT_UNUSED GtError *err)
{
  GtDlistelem *dlistelem;
  GtDlist *dlist;
  GT_UNUSED void *data;
  int elem = 1984;
  gt_error_check(err);

  dlist = gt_dlist_new(NULL);
  gt_dlist_add(dlist, &elem);
  gt_dlist_add(dlist, &elem);
  gt_dlist_add(dlist, &elem);

  /* a typical iterator loop */
  for (dlistelem = gt_dlist_first(dlist); dlistelem != NULL;
       dlistelem = gt_dlistelem_next(dlistelem)) {
    data = gt_dlistelem_get_data(dlistelem);
    /* do something with data */
  }

  gt_dlist_delete(dlist);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x7c0, 0x4(%rsp)       # imm = 0x7C0
testq %rdi, %rdi
je 0x72fbd
callq 0x3566a
testb %al, %al
jne 0x73024
leaq 0x7d550(%rip), %rdx     # 0xf0514
movl $0x1, %edi
movl $0x28, %esi
movl $0x31, %ecx
callq 0x3601f
movq %rax, %rbx
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x18(%rbx)
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72dd9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72dd9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72dd9
movq %rbx, %rdi
callq 0x72d30
movq %rbx, %rdi
callq 0x73029
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a7e8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dlist.c
// Function: gt_dlist_delete
void gt_dlist_delete(GtDlist *dlist)
{
  GtDlistelem *elem;
  if (!dlist) return;
  elem = dlist->first;
  while (elem) {
    gt_free(elem->previous);
    elem = elem->next;
  }
  gt_free(dlist->last);
  gt_free(dlist);
}

// Assembly:
testq %rdi, %rdi
je 0x7308c
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x7305f
leaq 0x7d4ce(%rip), %r14     # 0xf0514
movq (%r15), %rdi
movq %r14, %rsi
movl $0x173, %edx            # imm = 0x173
callq 0x362a0
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x73046
movq 0x10(%rbx), %rdi
leaq 0x7d4aa(%rip), %r14     # 0xf0514
movq %r14, %rsi
movl $0x176, %edx            # imm = 0x176
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x177, %edx            # imm = 0x177
popq %rbx
popq %r14
popq %r15
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dynalloc.c
// Function: gt_dynalloc
void* gt_dynalloc(void *ptr, size_t *allocated, size_t size)
{
  size_t size_to_alloc = 0;
  void *rptr;
  gt_assert(allocated && size);
  if (size <= *allocated)
    return ptr;
  if (*allocated == 0) {
    gt_assert(ptr == NULL);
    /* if nothing has been allocated already, we allocate what was asked for */
    size_to_alloc = size;
  }
  else {
    /* XXX: no overflow */
    gt_assert(*allocated != SIZE_MAX);
    /* otherwise we double the allocated space, if possible */
    size_to_alloc = *allocated;
    while (size_to_alloc < size) {
      if (size_to_alloc > SIZE_MAX / 2) size_to_alloc = SIZE_MAX;
      else size_to_alloc *= 2;
    }
  }
  gt_assert(size_to_alloc);
  rptr = gt_realloc(ptr, size_to_alloc);
  *allocated = size_to_alloc;
  return rptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x73c0b
testq %rdx, %rdx
je 0x73c0b
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
jae 0x73bd7
testq %rax, %rax
je 0x73bdc
cmpq %rdx, %rax
jae 0x73be9
movq $-0x1, %rcx
leaq (%rax,%rax), %r14
testq %rax, %rax
cmovsq %rcx, %r14
movq %r14, %rax
cmpq %rdx, %r14
jb 0x73bc2
jmp 0x73bec
movq %rdi, %rax
jmp 0x73c03
movq %rdx, %r14
testq %rdi, %rdi
je 0x73bec
callq 0x1a903
movq %rax, %r14
leaq 0x7ccb3(%rip), %rdx     # 0xf08a6
movq %r14, %rsi
movl $0x2c, %ecx
callq 0x36116
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a8cc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_init
void gt_fa_init(void)
{
  gt_assert(!fa);
  fa = gt_calloc(1, sizeof (FA));
  fa->file_mutex = gt_mutex_new();
  fa->mmap_mutex = gt_mutex_new();
  fa->file_pointer = gt_hashmap_new(GT_HASH_DIRECT, NULL,
                                    (GtFree) free_FAFileInfo);
  fa->memory_maps = gt_hashmap_new(GT_HASH_DIRECT, NULL,
                                   (GtFree) free_FAMapInfo);
  fa->global_space_peak = false;
}

// Assembly:
pushq %rax
cmpq $0x0, 0xdefb7(%rip)     # 0x152bd0
jne 0x73c98
leaq 0x7ccb3(%rip), %rdx     # 0xf08d5
movl $0x1, %edi
movl $0x38, %esi
movl $0x59, %ecx
callq 0x3601f
movq %rax, 0xdef93(%rip)     # 0x152bd0
callq 0x3d96a
movq 0xdef87(%rip), %rcx     # 0x152bd0
movq %rax, (%rcx)
callq 0x3d96a
movq 0xdef78(%rip), %rcx     # 0x152bd0
movq %rax, 0x8(%rcx)
leaq 0x3a(%rip), %rdx        # 0x73c9d
xorl %edi, %edi
xorl %esi, %esi
callq 0x76f28
movq 0xdef5d(%rip), %rcx     # 0x152bd0
movq %rax, 0x10(%rcx)
leaq 0x30(%rip), %rdx        # 0x73cae
xorl %edi, %edi
xorl %esi, %esi
callq 0x76f28
movq 0xdef42(%rip), %rcx     # 0x152bd0
movq %rax, 0x18(%rcx)
movb $0x0, 0x30(%rcx)
popq %rax
retq
callq 0x1a93a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_fopen_func
FILE* gt_fa_fopen_func(const char *path, const char *mode,
                       const char *src_file, int src_line, GtError *err)
{
  gt_error_check(err);
  gt_assert(path && mode);
  gt_assert(fa);
  return fileopen_generic(fa, path, mode, GT_FILE_MODE_UNCOMPRESSED, false,
                          src_file, src_line, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testq %r8, %r8
je 0x73ce7
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x73d2b
testq %r13, %r13
je 0x73d21
testq %r12, %r12
je 0x73d21
movq 0xdeed8(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x73d26
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x73d30
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1a9aa
callq 0x1a9e3
callq 0x1a971
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: fileopen_generic
static void* fileopen_generic(FA *fa, const char *path, const char *mode,
                              GtFileMode file_mode, bool x,
                              const char *src_file, int src_line, GtError *err)
{
  void  *fp = NULL;
  FAFileInfo *fileinfo;
  gt_error_check(err);
  gt_assert(fa && path && mode);
  fileinfo = gt_malloc(sizeof (FAFileInfo));
  fileinfo->src_file = src_file;
  fileinfo->src_line = src_line;
  switch (file_mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      fp = x ? gt_xfopen(path, mode) : gt_efopen(path, mode, err);
      break;
    case GT_FILE_MODE_GZIP:
      fp = x ? gt_xgzopen(path, mode) : gt_egzopen(path, mode, err);
      break;
    case GT_FILE_MODE_BZIP2:
      fp = x ? gt_xbzopen(path, mode) : gt_ebzopen(path, mode, err);
      break;
    default: gt_assert(0);
  }
  if (fp) {
    gt_mutex_lock(fa->file_mutex);
    gt_hashmap_add(fa->file_pointer, fp, fileinfo);
    gt_mutex_unlock(fa->file_mutex);
  }
  else
    gt_free(fileinfo);
  return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x73d6a
callq 0x3566a
testb %al, %al
jne 0x73e54
movl 0x50(%rsp), %r15d
leaq 0x7cb5f(%rip), %rsi     # 0xf08d5
movl $0x10, %edi
movl $0x6b, %edx
callq 0x35ee2
movq %rax, %r14
movq %r13, (%rax)
movl %r15d, 0x8(%rax)
movq %r12, %rdi
cmpl $0x2, %ebx
je 0x73dad
cmpl $0x1, %ebx
jne 0x73dbe
testb %bpl, %bpl
je 0x73dcf
movq 0x8(%rsp), %rsi
callq 0x837d0
jmp 0x73e00
testb %bpl, %bpl
je 0x73de0
movq 0x8(%rsp), %rsi
callq 0x834f8
jmp 0x73e00
testb %bpl, %bpl
je 0x73df1
movq 0x8(%rsp), %rsi
callq 0x3dbfa
jmp 0x73e00
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xa4d00
jmp 0x73e00
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xa4c9c
jmp 0x73e00
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xa4c38
movq %rax, %r15
testq %rax, %rax
je 0x73e2e
movq 0x10(%rsp), %rbx
movq (%rbx), %rdi
callq 0x3d9b7
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x77144
movq (%rbx), %rdi
callq 0x3d9d2
jmp 0x73e42
leaq 0x7caa0(%rip), %rsi     # 0xf08d5
movq %r14, %rdi
movl $0x80, %edx
callq 0x362a0
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1aa1c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xfopen_func
FILE* gt_fa_xfopen_func(const char *path, const char *mode,
                        const char *src_file, int src_line)
{
  gt_assert(path && mode);
  gt_assert(fa);
  return fileopen_generic(fa, path, mode, GT_FILE_MODE_UNCOMPRESSED, true,
                          src_file, src_line, NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x73e91
movq %rdx, %r9
movq %rsi, %rdx
testq %rsi, %rsi
je 0x73e91
movq %rdi, %rsi
movq 0xded5c(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x73e96
movl %ecx, %eax
xorl %ecx, %ecx
movl $0x1, %r8d
pushq $0x0
pushq %rax
callq 0x73d30
addq $0x10, %rsp
popq %rcx
retq
callq 0x1aa53
callq 0x1aa8c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_fopen_with_suffix_func
FILE* gt_fa_fopen_with_suffix_func(const char *path, const char *suffix,
                                   const char *mode, const char *src_file,
                                   int src_line, GtError *err)
{
  GtStr *tmpfilename;
  FILE *fp;
  gt_error_check(err);
  tmpfilename = gt_str_new_cstr(path);
  gt_str_append_cstr(tmpfilename, suffix);
  fp = gt_fa_fopen_func(gt_str_get(tmpfilename), mode, src_file, src_line, err);
  gt_str_delete(tmpfilename);
  return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testq %r9, %r9
je 0x73ec9
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x73f17
movq %r13, %rdi
callq 0x3c03d
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x3c067
movq %r13, %rdi
callq 0x3c40b
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x73cbf
movq %rax, %rbx
movq %r13, %rdi
callq 0x3d1eb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1aac5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: fclose_generic
static void fclose_generic(void *stream, GtFileMode file_mode, FA *fa)
{
  /*FAFileInfo *fileinfo;*/
  gt_assert(stream && fa);
  gt_mutex_lock(fa->file_mutex);
  /*fileinfo = gt_hashmap_get(fa->file_pointer, stream);*/
  gt_assert(gt_hashmap_get(fa->file_pointer, stream));
  gt_hashmap_remove(fa->file_pointer, stream);
  gt_mutex_unlock(fa->file_mutex);
  switch (file_mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      fclose(stream);
      break;
    case GT_FILE_MODE_GZIP:
      gzclose(stream);
      break;
    case GT_FILE_MODE_BZIP2:
      BZ2_bzclose(stream);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x3d9b7
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x77109
testq %rax, %rax
je 0x73f99
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x77182
movq (%r14), %rdi
callq 0x3d9d2
movq %rbx, %rdi
cmpl $0x2, %ebp
je 0x73f87
cmpl $0x1, %ebp
jne 0x73f90
popq %rbx
popq %r14
popq %rbp
jmp 0x9a2ec
popq %rbx
popq %r14
popq %rbp
jmp 0x9a115
popq %rbx
popq %r14
popq %rbp
jmp 0xb690
callq 0x1ab37
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: xfclose_generic
static void xfclose_generic(void *stream, GtFileMode file_mode, FA *fa)
{
  /*FAFileInfo *fileinfo;*/
  gt_assert(stream && fa);
  gt_mutex_lock(fa->file_mutex);
  /*fileinfo = gt_hashmap_get(fa->file_pointer, stream);*/
  gt_assert(gt_hashmap_get(fa->file_pointer, stream));
  gt_hashmap_remove(fa->file_pointer, stream);
  gt_mutex_unlock(fa->file_mutex);
  switch (file_mode) {
    case GT_FILE_MODE_UNCOMPRESSED:
      gt_xfclose(stream);
      break;
    case GT_FILE_MODE_GZIP:
      gt_xgzclose(stream);
      break;
    case GT_FILE_MODE_BZIP2:
      BZ2_bzclose(stream);
      break;
    default: gt_assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x3d9b7
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x77109
testq %rax, %rax
je 0x7401b
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x77182
movq (%r14), %rdi
callq 0x3d9d2
movq %rbx, %rdi
cmpl $0x2, %ebp
je 0x74009
cmpl $0x1, %ebp
jne 0x74012
popq %rbx
popq %r14
popq %rbp
jmp 0x838ce
popq %rbx
popq %r14
popq %rbp
jmp 0x9a115
popq %rbx
popq %r14
popq %rbp
jmp 0x3db69
callq 0x1aba9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_gzopen_func
gzFile gt_fa_gzopen_func(const char *path, const char *mode,
                         const char *src_file, int src_line, GtError *err)
{
  gt_error_check(err);
  gt_assert(path && mode);
  gt_assert(fa);
  return fileopen_generic(fa, path, mode, GT_FILE_MODE_GZIP, false, src_file,
                          src_line, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testq %r8, %r8
je 0x7408c
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x740d3
testq %r13, %r13
je 0x740c9
testq %r12, %r12
je 0x740c9
movq 0xdeb33(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x740ce
movq %r13, %rsi
movq %r12, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x73d30
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1ac8d
callq 0x1acc6
callq 0x1ac54
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xgzopen_func
gzFile gt_fa_xgzopen_func(const char *path, const char *mode,
                          const char *src_file, int src_line)
{
  gt_assert(path && mode);
  gt_assert(fa);
  return fileopen_generic(fa, path, mode, GT_FILE_MODE_GZIP, true, src_file,
                          src_line, NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74113
movq %rdx, %r9
movq %rsi, %rdx
testq %rsi, %rsi
je 0x74113
movq %rdi, %rsi
movq 0xdeadd(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x74118
movl %ecx, %eax
movl $0x1, %ecx
movl $0x1, %r8d
pushq $0x0
pushq %rax
callq 0x73d30
addq $0x10, %rsp
popq %rcx
retq
callq 0x1acff
callq 0x1ad38
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_bzopen_func
BZFILE* gt_fa_bzopen_func(const char *path, const char *mode,
                          const char *src_file, int src_line, GtError *err)
{
  gt_error_check(err);
  gt_assert(path && mode);
  gt_assert(fa);
  return fileopen_generic(fa, path, mode, GT_FILE_MODE_BZIP2, false, src_file,
                          src_line, err);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testq %r8, %r8
je 0x74189
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x741d0
testq %r13, %r13
je 0x741c6
testq %r12, %r12
je 0x741c6
movq 0xdea36(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x741cb
movq %r13, %rsi
movq %r12, %rdx
movl $0x2, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x73d30
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1ae1c
callq 0x1ae55
callq 0x1ade3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_read_func
void* gt_fa_mmap_read_func(const char *path, size_t *len,
                           const char *src_file, int src_line, GtError *err)
{
  gt_error_check(err);
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func(path, len, false, false, src_file, src_line,
                                err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r12
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
testq %r8, %r8
je 0x7463a
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0x7467a
testq %r13, %r13
je 0x74670
cmpq $0x0, 0xde589(%rip)     # 0x152bd0
je 0x74675
movq %r12, (%rsp)
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movl %ebx, %r9d
callq 0x7467f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1b13a
callq 0x1b101
callq 0x1b0c8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: mmap_generic_path_func
static void* mmap_generic_path_func(const char *path, size_t *len,
                                    bool mapwritable, bool hard_fail,
                                    const char *src_file, int src_line,
                                    GtError *err)
{
  int fd;
  void *map;
  size_t file_size;

  gt_error_check(err);
  gt_assert(fa && path);
  fd = open(path, mapwritable?O_RDWR:O_RDONLY, 0);
  if (fd == -1) {
    gt_error_set(err,"cannot open file \"%s\": %s", path, strerror(errno));
    return NULL;
  }
  file_size = fd_to_file_size(fd,path,hard_fail,err);
  if (file_size == -1)
  {
    return NULL;
  }
  map = gt_fa_mmap_generic_fd_func(fd, path, file_size, 0, mapwritable,
                                   hard_fail, src_file, src_line, err);
  if (map != NULL && len != NULL)
    *len = file_size;
  gt_xclose(fd);
  return map;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r9d, %r13d
movq %r8, %r12
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0xe0(%rsp), %r14
testq %r14, %r14
je 0x746bf
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x747d9
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
cmpq $0x0, 0xde500(%rip)     # 0x152bd0
je 0x747d4
movzbl %bl, %r13d
leal (,%r13,2), %esi
movq %r15, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xbae0
cmpl $-0x1, %eax
je 0x74709
movl %eax, %r12d
leaq 0x18(%rsp), %rsi
movl %eax, %edi
testb %bpl, %bpl
je 0x74734
callq 0x83617
jmp 0x74769
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x7c633(%rip), %rsi     # 0xf0d4f
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3559f
jmp 0x747bf
callq 0xbb90
testl %eax, %eax
je 0x74769
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x7c619(%rip), %rsi     # 0xf0d69
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3559f
movq $-0x1, %rbx
jmp 0x7476e
movq 0x48(%rsp), %rbx
cmpq $-0x1, %rbx
je 0x747bc
subq $0x8, %rsp
movzbl %bpl, %r9d
movl %r12d, %edi
movq %r15, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
movl %r13d, %r8d
pushq %r14
pushq 0x10(%rsp)
pushq 0x20(%rsp)
callq 0x744a3
addq $0x20, %rsp
movq %rax, %r13
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x747b2
testq %r13, %r13
je 0x747b2
movq %rbx, (%rax)
movl %r12d, %edi
callq 0x835f4
jmp 0x747bf
xorl %r13d, %r13d
movq %r13, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b1ac
callq 0x1b173
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_read_func_range
void* gt_fa_mmap_read_func_range(const char *path, size_t len, size_t offset,
                                 const char *src_file, int src_line,
                                 GtError *err)
{
  gt_error_check(err);
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func_range(path, len, offset, false, false,
                                      src_file, src_line, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
testq %r9, %r9
je 0x7480c
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x7484d
testq %rbp, %rbp
je 0x74843
cmpq $0x0, 0xde3b7(%rip)     # 0x152bd0
je 0x74848
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x74852
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b257
callq 0x1b21e
callq 0x1b1e5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: mmap_generic_path_func_range
static void* mmap_generic_path_func_range(const char *path, size_t len,
                                          size_t offset,
                                          bool mapwritable, bool hard_fail,
                                          const char *src_file, int src_line,
                                          GtError *err)
{
  int fd;
  void *map;

  gt_error_check(err);
  gt_assert(fa && path);
  fd = open(path, mapwritable?O_RDWR:O_RDONLY, 0);
  if (fd == -1) {
    gt_error_set(err,"cannot open file \"%s\": %s", path, strerror(errno));
    return NULL;
  }
  map = gt_fa_mmap_generic_fd_func(fd, path, len, offset, mapwritable,
                                   hard_fail, src_file, src_line, err);
  gt_xclose(fd);
  return map;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, (%rsp)
movq %rsi, %r13
movq %rdi, %r14
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x74886
callq 0x3566a
testb %al, %al
jne 0x74926
cmpq $0x0, 0xde342(%rip)     # 0x152bd0
je 0x74921
movzbl %bl, %ebx
leal (%rbx,%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xbae0
cmpl $-0x1, %eax
je 0x748eb
movl %eax, %r15d
movl 0x40(%rsp), %eax
subq $0x8, %rsp
movzbl %bpl, %r9d
movl %r15d, %edi
movq %r14, %rsi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movl %ebx, %r8d
pushq 0x50(%rsp)
pushq %rax
pushq %r12
callq 0x744a3
addq $0x20, %rsp
movq %rax, %rbx
movl %r15d, %edi
callq 0x835f4
movq %rbx, %rax
jmp 0x74912
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0x7c451(%rip), %rsi     # 0xf0d4f
movq 0x48(%rsp), %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3559f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b2c9
callq 0x1b290
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_write_func
void* gt_fa_mmap_write_func(const char *path, size_t *len,
                            const char *src_file, int src_line, GtError *err)
{
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func(path, len, true, false, src_file, src_line,
                                err);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74956
cmpq $0x0, 0xde297(%rip)     # 0x152bd0
je 0x7495b
movl %ecx, %r9d
movq %rdx, %rax
movq %r8, (%rsp)
movl $0x1, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x7467f
popq %rcx
retq
callq 0x1b33b
callq 0x1b302
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_mmap_write_func_range
void* gt_fa_mmap_write_func_range(const char *path, size_t len, size_t offset,
                                  const char *src_file, int src_line,
                                  GtError *err)
{
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func_range(path, len, offset, true, false, src_file,
                                      src_line, err);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7498f
cmpq $0x0, 0xde262(%rip)     # 0x152bd0
je 0x74994
movq %r9, %r10
movl %r8d, %eax
movq %rcx, %r9
movl $0x1, %ecx
xorl %r8d, %r8d
pushq %r10
pushq %rax
callq 0x74852
addq $0x10, %rsp
popq %rcx
retq
callq 0x1b3ad
callq 0x1b374
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xmmap_read_func
void* gt_fa_xmmap_read_func(const char *path, size_t *len,
                            const char *src_file, int src_line)
{
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func(path, len, false, true, src_file, src_line,
                                NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x749c5
cmpq $0x0, 0xde229(%rip)     # 0x152bd0
je 0x749ca
movl %ecx, %r9d
movq %rdx, %r8
movq $0x0, (%rsp)
xorl %edx, %edx
movl $0x1, %ecx
callq 0x7467f
popq %rcx
retq
callq 0x1b41f
callq 0x1b3e6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_heap_read_func
void *gt_fa_heap_read_func(const char *path, size_t *len,
                           const char *src_file, int src_line, GtError *err)
{
  int fd;
  struct stat buf;
  bool haserr = false;

  gt_assert(path != NULL);
  fd = open(path,O_RDONLY); /* open file for read, get filedes */
  if (fd == -1) /* check for error code */
  {
    gt_error_set(err,"%s, line %d: cannot open \"%s\"",src_file,src_line,path);
    haserr = true;
  }
  if (!haserr && fstat(fd,&buf) == -1)  /* get status information of file */
  {
    gt_error_set(err,"%s, line %d: cannot access status of file \"%s\"",
                 src_file,src_line,path);
    close(fd);
    haserr = true;
  }
  if (!haserr)
  {
    void *ptr;

    *len = buf.st_size;
    ptr = gt_malloc(*len);
    gt_assert(fd > 0);
    if (read(fd,ptr,*len) == -1)
    {
      gt_error_set(err,"%s, line %d: read(%s) failed",src_file,src_line,path);
      haserr = true;
    }
    if (haserr)
    {
      gt_free(ptr);
      return NULL;
    }
    close(fd);
    return ptr;
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x8(%rsp)
testq %rdi, %rdi
je 0x74afc
movq %r8, %r12
movl %ecx, %ebx
movq %rsi, %r13
movq %rdi, %r14
xorl %r15d, %r15d
xorl %esi, %esi
xorl %eax, %eax
callq 0xbae0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x74a2a
leaq 0x7c0f9(%rip), %rsi     # 0xf0b0c
movq %r12, %rdi
movq 0x8(%rsp), %rdx
movl %ebx, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x3559f
movb $0x1, %r15b
testb %r15b, %r15b
jne 0x74a65
leaq 0x18(%rsp), %rsi
movl %ebp, %edi
callq 0xbb90
cmpl $-0x1, %eax
jne 0x74a65
leaq 0x7c0e3(%rip), %rsi     # 0xf0b2a
movq %r12, %rdi
movq 0x8(%rsp), %rdx
movl %ebx, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x3559f
movl %ebp, %edi
callq 0xbcd0
movb $0x1, %r15b
testb %r15b, %r15b
jne 0x74adc
movl %ebx, 0x14(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, (%r13)
leaq 0x7be57(%rip), %rsi     # 0xf08d5
movl $0x262, %edx            # imm = 0x262
callq 0x35ee2
testl %ebp, %ebp
jle 0x74b01
movq %rax, %rbx
movq (%r13), %rdx
movl %ebp, %edi
movq %rax, %rsi
callq 0xb8e0
cmpq $-0x1, %rax
jne 0x74ac3
leaq 0x7c0b6(%rip), %rsi     # 0xf0b60
movq %r12, %rdi
movq 0x8(%rsp), %rdx
movl 0x14(%rsp), %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x3559f
movb $0x1, %r15b
testb %r15b, %r15b
je 0x74ae0
leaq 0x7be06(%rip), %rsi     # 0xf08d5
movq %rbx, %rdi
movl $0x26b, %edx            # imm = 0x26B
callq 0x362a0
xorl %ebx, %ebx
jmp 0x74ae7
movl %ebp, %edi
callq 0xbcd0
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1b491
callq 0x1b458
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fa.c
// Function: gt_fa_xmmap_read_func_range
void* gt_fa_xmmap_read_func_range(const char *path, size_t len, size_t offset,
                                  const char *src_file, int src_line)
{
  gt_assert(path);
  gt_assert(fa);
  return mmap_generic_path_func_range(path, len, offset, false, true,
                                      src_file, src_line, NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x74b32
cmpq $0x0, 0xde0bc(%rip)     # 0x152bd0
je 0x74b37
movl %r8d, %eax
movq %rcx, %r9
xorl %ecx, %ecx
movl $0x1, %r8d
pushq $0x0
pushq %rax
callq 0x74852
addq $0x10, %rsp
popq %rcx
retq
callq 0x1b503
callq 0x1b4ca