LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/class_alloc.c
// Function: gt_class_alloc
void* gt_class_alloc(size_t size)
{
  void *c_class;
  if (!c_classes)
    c_classes = gt_array_new(sizeof (void*));
  c_class = gt_calloc(1, size);
  gt_array_add(c_classes, c_class);
  return c_class;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0xe092c(%rip)     # 0x152bb0
jne 0x72297
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0xe0919(%rip)     # 0x152bb0
leaq 0x7dda2(%rip), %rdx     # 0xf0040
movl $0x1, %edi
movq %rbx, %rsi
movl $0x1d, %ecx
callq 0x359a6
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq 0xe08f1(%rip), %rdi     # 0x152bb0
movl $0x8, %edx
movq %rbx, %rsi
callq 0x6f240
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/class_alloc.c
// Function: gt_class_alloc_clean
void  gt_class_alloc_clean(void)
{
  GtUword i;
  if (!c_classes) return;
  for (i = 0; i < gt_array_size(c_classes); i++)
    gt_free(*(void**) gt_array_get(c_classes, i));
  gt_array_delete(c_classes);
  c_classes = NULL;
}

// Assembly:
movq 0xe08d4(%rip), %rdi     # 0x152bb0
testq %rdi, %rdi
je 0x72349
pushq %r14
pushq %rbx
pushq %rax
callq 0x6f310
testq %rax, %rax
je 0x7232b
xorl %ebx, %ebx
leaq 0x7dd48(%rip), %r14     # 0xf0040
movq 0xe08b1(%rip), %rdi     # 0x152bb0
movq %rbx, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %r14, %rsi
movl $0x27, %edx
callq 0x35c27
incq %rbx
movq 0xe088f(%rip), %rdi     # 0x152bb0
callq 0x6f310
cmpq %rax, %rbx
jb 0x722f8
movq 0xe087e(%rip), %rdi     # 0x152bb0
callq 0x6f768
movq $0x0, 0xe086e(%rip) # 0x152bb0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/combinatorics.c
// Function: gt_combinatorics_init
static inline void init_ln_n_fac_tab(void)
{
  GtUword idx;

  if (ln_n_fac_tab == NULL) {
    ln_n_fac_tab = gt_calloc((size_t) (GT_BINOMIAL_MAX_N_LN + 1),
                             sizeof (double));

    ln_n_fac_tab[0] = log(1.0);
    for (idx = 1UL; idx <= GT_BINOMIAL_MAX_N_LN; idx++) {
      ln_n_fac_tab[idx] = log((double) idx) + ln_n_fac_tab[idx-1];
    }
    gt_log_log("ln_fac_max: %lf", ln_n_fac_tab[GT_BINOMIAL_MAX_N_LN]);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0xe0820(%rip)     # 0x152bc0
jne 0x7240e
leaq 0x7dd1c(%rip), %rdx     # 0xf00c5
movl $0x43, %edi
movl $0x8, %esi
movl $0x2c, %ecx
callq 0x359a6
movq %rax, 0xe07fc(%rip)     # 0x152bc0
movq $0x0, (%rax)
movl $0x1, %ebx
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
callq 0xb4d0
movq 0xe07dc(%rip), %rax     # 0x152bc0
addsd -0x8(%rax,%rbx,8), %xmm0
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
cmpq $0x43, %rbx
jne 0x723d0
movsd 0x210(%rax), %xmm0
leaq 0x7dd6f(%rip), %rdi     # 0xf0176
movb $0x1, %al
callq 0x353ae
cmpq $0x0, 0xe07b2(%rip)     # 0x152bc8
jne 0x724eb
leaq 0x7dca2(%rip), %rbx     # 0xf00c5
movl $0x220, %edi            # imm = 0x220
movq %rbx, %rsi
movl $0x3c, %edx
callq 0x35862
movq %rax, 0xe078c(%rip)     # 0x152bc8
movl $0x4840, %edi           # imm = 0x4840
movq %rbx, %rsi
movl $0x3c, %edx
callq 0x35862
movq 0xe0773(%rip), %rbx     # 0x152bc8
movq %rax, (%rbx)
addq $0x110, %rax            # imm = 0x110
movl $0x1, %ecx
movq %rax, (%rbx,%rcx,8)
incq %rcx
addq $0x110, %rax            # imm = 0x110
cmpq $0x44, %rcx
jne 0x72463
movq (%rbx), %rdi
addq $0x8, %rdi
xorl %r14d, %r14d
movl $0x108, %edx            # imm = 0x108
xorl %esi, %esi
callq 0xb2f0
movq (%rbx,%r14,8), %rax
movq $0x1, (%rax)
incq %r14
cmpq $0x44, %r14
jne 0x7248c
movl $0x1, %eax
movl $0x1, %ecx
movl $0x1, %edx
cmpq %rcx, %rax
jbe 0x724d1
movq -0x8(%rbx,%rax,8), %rdx
movq -0x8(%rdx,%rcx,8), %rsi
movq (%rdx,%rcx,8), %rdx
testq %rdx, %rdx
je 0x724ce
addq %rsi, %rdx
jae 0x724d1
jmp 0x724f3
movq %rsi, %rdx
movq (%rbx,%rax,8), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq $0x22, %rcx
jne 0x724aa
incq %rax
cmpq $0x44, %rax
jne 0x724a5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19e17
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/combinatorics.c
// Function: gt_combinatorics_clean
void gt_combinatorics_clean(void)
{
  gt_free(ln_n_fac_tab);
  ln_n_fac_tab = NULL;
  gt_array2dim_delete(binomial_dp_tab);
  binomial_dp_tab = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xe06bd(%rip), %rdi     # 0x152bc0
leaq 0x7dbbb(%rip), %rbx     # 0xf00c5
movq %rbx, %rsi
movl $0x56, %edx
callq 0x35c27
xorl %r14d, %r14d
movq %r14, 0xe069f(%rip)     # 0x152bc0
movq 0xe06a0(%rip), %rax     # 0x152bc8
movq (%rax), %rdi
movq %rbx, %rsi
movl $0x58, %edx
callq 0x35c27
movq 0xe0689(%rip), %rdi     # 0x152bc8
movq %rbx, %rsi
movl $0x58, %edx
callq 0x35c27
movq %r14, 0xe0675(%rip)     # 0x152bc8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/combinatorics.c
// Function: gt_combinatorics_binomial_ln
GtUword gt_combinatorics_binomial_ln(GtUword n, GtUword k)
{
  if (k == 0 || n <= k)
    return 1UL;
  if (n < k)
    return 0;
  gt_assert(n <= GT_BINOMIAL_MAX_N_LN);
  if (GT_DIV2(n) < k)
    k = n - k;

  return gt_safe_cast2ulong(gt_round_to_long(exp(ln_n_fac_tab[n] -
                                                 ln_n_fac_tab[k] -
                                                 ln_n_fac_tab[n - k])));
}

// Assembly:
pushq %rax
testq %rsi, %rsi
sete %cl
movq %rdi, %rax
subq %rsi, %rax
setbe %dl
orb %cl, %dl
jne 0x725d4
cmpq $0x43, %rdi
jae 0x725db
movq %rdi, %rcx
shrq %rcx
cmpq %rsi, %rcx
cmovaeq %rsi, %rax
movq 0xe0627(%rip), %rcx     # 0x152bc0
movsd (%rcx,%rdi,8), %xmm0
subsd (%rcx,%rax,8), %xmm0
subq %rax, %rdi
subsd (%rcx,%rdi,8), %xmm0
callq 0xbb70
callq 0x7a71a
leaq 0x7db09(%rip), %rsi     # 0xf00c5
leaq 0xcaa1(%rip), %rcx      # 0x7f064
movq %rax, %rdi
movl $0x6d, %edx
xorl %r8d, %r8d
popq %rax
jmp 0x7f170
movl $0x1, %eax
popq %rcx
retq
callq 0x19e42
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/combinatorics.c
// Function: gt_combinatorics_binomial_simple
GtUword gt_combinatorics_binomial_simple(GtUword n, GtUword k)
{
  GtUword idx;
  GtUword result;
  if (n < k)
    return 0;
  if (k == 0 || k == n)
    return 1UL;
  gt_assert(n <= GT_BINOMIAL_MAX_N);
  if (GT_DIV2(n) < k)
    k = n - k;
  result = n - k + 1;
  for (idx = 2UL; idx <= k; idx++) {
#if defined (_LP64) || defined (_WIN64)
    result = (GtUword) gt_safe_mult_u64((uint64_t) result,
                                              (uint64_t) (n - k + idx));
#else
    result = (GtUword) gt_safe_mult_u32((uint32_t) result,
                                              (uint32_t) (n - k + idx));
#endif
    result /= idx;
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rsi, %rdi
jae 0x725f2
xorl %eax, %eax
jmp 0x72668
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
movq %rdi, %r12
subq %rsi, %r12
sete %cl
orb %al, %cl
movl $0x1, %eax
jne 0x72668
cmpq $0x3f, %rbx
jae 0x72672
movq %rbx, %rax
shrq %rax
cmpq %rsi, %rax
cmovaeq %rsi, %r12
subq %r12, %rbx
leaq 0x1(%rbx), %rax
cmpq $0x2, %r12
jb 0x72668
movl $0x2, %r13d
leaq 0x7da8b(%rip), %r14     # 0xf00c5
leaq 0xca23(%rip), %r15      # 0x7f064
leaq (%rbx,%r13), %rsi
movq %rax, %rdi
movq %r14, %rdx
movl $0x7f, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x7f0c5
xorl %edx, %edx
divq %r13
incq %r13
cmpq %r12, %r13
jbe 0x72641
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x19e79
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/combinatorics.c
// Function: gt_combinatorics_unit_test
int gt_combinatorics_unit_test(GtError *err)
{
  int had_err = 0;
  GtUword n,k;
  static const GtUword max_n = GT_BINOMIAL_MAX_N,
                             max_fac_stable = 47UL;
  gt_error_check(err);
  for (n = 0; n <= max_n; n++) {
    for (k = 0; k <= GT_DIV2(n); k++) {
      GtUword a = gt_combinatorics_binomial_dp(n, k),
                    b = gt_combinatorics_binomial_simple(n, k),
                    c;
      gt_ensure(a == b);
      if (n < max_fac_stable) {
        c = gt_combinatorics_binomial_ln(n,k);
        gt_ensure(c == a);
      }
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7269a
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x72792
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r15, %r12
shrq %r12
incq %r12
xorl %ebp, %ebp
movq 0xe0516(%rip), %rax     # 0x152bc8
movq (%rax,%r15,8), %rax
movq (%rax,%rbp,8), %r13
movq %r15, %rdi
movq %rbp, %rsi
callq 0x725e0
testl %r14d, %r14d
jne 0x72750
cmpq %rax, %r13
jne 0x72724
xorl %r14d, %r14d
cmpq $0x2f, %r15
jae 0x72767
movq %r15, %rdi
movq %rbp, %rsi
callq 0x7256b
cmpq %r13, %rax
je 0x72767
movq %rbx, %rdi
leaq 0x70a5f(%rip), %rsi     # 0xe3159
leaq 0x7da6e(%rip), %rdx     # 0xf016f
leaq 0x7da45(%rip), %rcx     # 0xf014d
leaq 0x7d9b6(%rip), %r8      # 0xf00c5
movl $0x98, %r9d
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x72767
movq %rbx, %rdi
leaq 0x70a2b(%rip), %rsi     # 0xe3159
leaq 0x7da33(%rip), %rdx     # 0xf0168
leaq 0x7da11(%rip), %rcx     # 0xf014d
leaq 0x7d982(%rip), %r8      # 0xf00c5
movl $0x95, %r9d
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpq $0x2f, %r15
jae 0x72767
movq %r15, %rdi
movq %rbp, %rsi
callq 0x7256b
incq %rbp
cmpq %rbp, %r12
jne 0x726ab
incq %r15
cmpq $0x3f, %r15
jne 0x726a0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19eb0
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/cstr.c
// Function: gt_cstr_split
char** gt_cstr_split(const char *cstr, char sep)
{
  size_t n = 0;
  char **res;
  GtUword i,
                lastpos = 0,
                respos = 0;
  gt_assert(cstr);

  for (i = 0; i < strlen(cstr); i++) {
    if (cstr[i] == sep)
      n++;
  }
  n++;
  res = gt_calloc(n+1, sizeof (char*));
  for (i = 0; i < strlen(cstr)+1; i++) {
    if (cstr[i] == sep || cstr[i] == '\0') {
      if (i != 0)
        res[respos] = gt_calloc(i - lastpos + 1, sizeof (char));
      if (i - lastpos >= 1)
        memcpy(res[respos], cstr + lastpos, (i - lastpos) * sizeof (char));
      lastpos = i+1;
      respos++;
    }
  }
  gt_assert(respos == n);
  res[respos] = NULL;
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x728b6
movl %esi, %ebx
movq %rdi, %r14
callq 0xb260
testq %rax, %rax
je 0x727d8
xorl %ecx, %ecx
xorl %ebp, %ebp
xorl %edx, %edx
cmpb %bl, (%r14,%rcx)
sete %dl
addq %rdx, %rbp
incq %rcx
cmpq %rcx, %rax
jne 0x727c2
jmp 0x727da
xorl %ebp, %ebp
leaq 0x1(%rbp), %rax
movq %rax, 0x10(%rsp)
leaq 0x2(%rbp), %rdi
leaq 0x7d9c6(%rip), %rdx     # 0xf01b4
movl $0x8, %esi
movl $0x28, %ecx
callq 0x359a6
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0xb260
xorl %r12d, %r12d
cmpq $-0x1, %rax
je 0x72892
xorl %r15d, %r15d
xorl %r13d, %r13d
movb (%r14,%r13), %al
cmpb %bl, %al
sete %cl
testb %al, %al
sete %al
orb %cl, %al
je 0x7287f
testq %r13, %r13
je 0x72858
movq %r13, %rdi
subq %r15, %rdi
incq %rdi
movl $0x1, %esi
leaq 0x7d96f(%rip), %rdx     # 0xf01b4
movl $0x2c, %ecx
callq 0x359a6
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%r12,8)
movq %r13, %rdx
subq %r15, %rdx
je 0x72874
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rdi
addq %r14, %r15
movq %r15, %rsi
callq 0xb520
incq %r13
incq %r12
movq %r13, %r15
jmp 0x72882
incq %r13
movq %r14, %rdi
callq 0xb260
incq %rax
cmpq %rax, %r13
jb 0x72819
cmpq 0x10(%rsp), %r12
jne 0x728bb
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax,%rbp,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19f20
callq 0x19ee9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/cstr.c
// Function: gt_cstr_dup
char* gt_cstr_dup(const char *cstr)
{
  size_t size;
  char *copy;
  gt_assert(cstr);
  size = strlen(cstr) + 1;
  copy = gt_malloc(size);
  memcpy(copy, cstr, size);
  return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x728fe
movq %rdi, %rbx
callq 0xb260
leaq 0x1(%rax), %r14
leaq 0x7d8d8(%rip), %rsi     # 0xf01b4
movq %r14, %rdi
movl $0x3e, %edx
callq 0x35862
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb520
callq 0x19f57
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/cstr.c
// Function: gt_cstr_dup_nt
char* gt_cstr_dup_nt(const char *cstr, GtUword length)
{
  char *copy;
  gt_assert(cstr);
  copy = gt_malloc(length+1);
  memcpy(copy, cstr, length);
  copy[length] = '\0';
  return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x72947
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
leaq 0x7d896(%rip), %rsi     # 0xf01b4
movl $0x47, %edx
callq 0x35862
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb520
movb $0x0, (%r15,%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x19f8e
// File: /workspace/github_c_makefile_star2_O3/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 0x7296e
movb (%rdi), %al
testb %al, %al
je 0x7296c
incq %rdi
cmpb %sil, %al
jne 0x72963
movb %dl, -0x1(%rdi)
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x7295b
popq %rax
retq
callq 0x19fc5
// File: /workspace/github_c_makefile_star2_O3/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 0x729b7
movq %rdx, %rbx
testq %rdx, %rdx
je 0x729b7
movq %rsi, %r14
testq %rsi, %rsi
je 0x729ab
movq %rdi, %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
movq %rbx, %rsi
callq 0x3d29e
incq %r12
cmpq %r12, %r14
jne 0x72996
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x19ffc
// File: /workspace/github_c_makefile_star2_O3/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 0x729e1
movq %rdi, %rbx
movsbl %sil, %esi
callq 0xb210
testq %rax, %rax
je 0x729d8
subq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0xb260
callq 0x1a033
// File: /workspace/github_c_makefile_star2_O3/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 0x72a1e
movl %esi, %ebp
movq %rdi, %rbx
callq 0xb260
leaq (%rax,%rbx), %rcx
decq %rcx
movq %rcx, %rax
cmpq %rbx, %rcx
jb 0x72a10
leaq -0x1(%rax), %rcx
cmpb %bpl, (%rax)
je 0x729ff
movb $0x0, 0x1(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1a06a
// File: /workspace/github_c_makefile_star2_O3/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 0x72a42
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x72bf8
leaq 0x7d7ee(%rip), %rdi     # 0xf0237
movl $0x20, %esi
callq 0x72798
movq %rax, %r14
movq (%rax), %rdi
leaq 0x7f181(%rip), %rsi     # 0xf1be1
callq 0xb890
testl %eax, %eax
je 0x72a96
leaq 0x706e9(%rip), %rsi     # 0xe3159
leaq 0x7d7df(%rip), %rdx     # 0xf0256
leaq 0x7d7c6(%rip), %rcx     # 0xf0244
leaq 0x7d72f(%rip), %r8      # 0xf01b4
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x7c, %r9d
jmp 0x72b7b
movq 0x8(%r14), %rax
cmpb $0x0, (%rax)
je 0x72acc
leaq 0x706b3(%rip), %rsi     # 0xe3159
leaq 0x7d7c4(%rip), %rdx     # 0xf0271
leaq 0x7d790(%rip), %rcx     # 0xf0244
leaq 0x7d6f9(%rip), %r8      # 0xf01b4
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x7d, %r9d
jmp 0x72b7b
movq 0x10(%r14), %rdi
leaq 0x7e7a0(%rip), %rsi     # 0xf1277
callq 0xb890
testl %eax, %eax
je 0x72b0a
leaq 0x70672(%rip), %rsi     # 0xe3159
leaq 0x7d79b(%rip), %rdx     # 0xf0289
leaq 0x7d74f(%rip), %rcx     # 0xf0244
leaq 0x7d6b8(%rip), %r8      # 0xf01b4
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x7e, %r9d
jmp 0x72b7b
movq 0x18(%r14), %rdi
leaq 0x7d72b(%rip), %rsi     # 0xf0240
callq 0xb890
testl %eax, %eax
je 0x72b48
leaq 0x70634(%rip), %rsi     # 0xe3159
leaq 0x7d778(%rip), %rdx     # 0xf02a4
leaq 0x7d711(%rip), %rcx     # 0xf0244
leaq 0x7d67a(%rip), %r8      # 0xf01b4
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x7f, %r9d
jmp 0x72b7b
cmpq $0x0, 0x20(%r14)
je 0x72bf3
leaq 0x705ff(%rip), %rsi     # 0xe3159
leaq 0x7d75e(%rip), %rdx     # 0xf02bf
leaq 0x7d6dc(%rip), %rcx     # 0xf0244
leaq 0x7d645(%rip), %r8      # 0xf01b4
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x80, %r9d
xorl %eax, %eax
callq 0x34f1f
movq %r14, %rdi
callq 0x72eac
leaq 0x7bfa6(%rip), %rdi     # 0xeeb37
movl $0x20, %esi
callq 0x72798
movq %rax, %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r15b, %r15b
je 0x72bde
cmpq $0x0, (%r14)
je 0x72bdc
leaq 0x705a4(%rip), %rsi     # 0xe3159
leaq 0x7d712(%rip), %rdx     # 0xf02ce
leaq 0x7d681(%rip), %rcx     # 0xf0244
leaq 0x7d5ea(%rip), %r8      # 0xf01b4
movq %rbx, %rdi
movl $0x84, %r9d
xorl %eax, %eax
callq 0x34f1f
jmp 0x72bde
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x72eac
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0x72b82
callq 0x1a0a1
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x72c75
movq %rdi, %rbx
movl $0x1, %r12d
xorl %r14d, %r14d
decq %r12
cmpq $0x0, (%rbx,%r14)
leaq 0x8(%r14), %r14
jne 0x72c1a
leaq 0x7d6cb(%rip), %rsi     # 0xf02fa
movq %r14, %rdi
movl $0x1e, %edx
callq 0x35862
movq %rax, %r15
testq %r12, %r12
je 0x72c5f
negq %r12
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rdi
callq 0x728c0
movq %rax, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x72c4a
movq $0x0, -0x8(%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1a0d8
// File: /workspace/github_c_makefile_star2_O3/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 0x72d56
movq %rsi, %r15
testq %rsi, %rsi
je 0x72d56
movq %rdi, %rbx
movl $0x1, %r13d
xorl %r14d, %r14d
decq %r13
cmpq $0x0, (%rbx,%r14)
leaq 0x8(%r14), %r14
jne 0x72ca6
leaq 0x7d63f(%rip), %rsi     # 0xf02fa
movq %r14, %rdi
movl $0x2b, %edx
callq 0x35862
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 0x7d60b(%rip), %rsi     # 0xf02fa
movl $0x2d, %edx
callq 0x35862
movq %rax, (%r12)
movq (%rbx), %r8
leaq 0x6f482(%rip), %rdx     # 0xe2189
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0xba10
negq %r13
cmpq $0x2, %r13
jb 0x72d3b
movl $0x1, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x728c0
movq %rax, (%r12,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x72d26
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 0x1a10f
// File: /workspace/github_c_makefile_star2_O3/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 0x72e01
movq %rsi, %r15
testq %rsi, %rsi
je 0x72e01
movq %rdi, %rbx
movl $0x1, %r13d
movl $0x8, %r14d
decq %r13
cmpq $0x0, -0x8(%rbx,%r14)
leaq 0x8(%r14), %r14
jne 0x72d98
leaq 0x7d54c(%rip), %rsi     # 0xf02fa
movq %r14, %rdi
movl $0x3b, %edx
callq 0x35862
movq %rax, %r12
movq %r15, %rdi
callq 0x728c0
movq %rax, (%r12)
testq %r13, %r13
je 0x72deb
negq %r13
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x728c0
movq %rax, 0x8(%r12,%r15,8)
incq %r15
cmpq %r15, %r13
jne 0x72dd5
movq $0x0, -0x8(%r12,%r14)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1a146
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x72e47
xorl %r15d, %r15d
testq %r15, %r15
je 0x72e32
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3d29e
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x3d2b0
movq 0x8(%r14,%r15,8), %rdi
incq %r15
testq %rdi, %rdi
jne 0x72e1c
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3d29e
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x72e9a
xorl %r15d, %r15d
testq %r15, %r15
je 0x72e85
movl $0x20, %edi
movq %rbx, %rsi
callq 0x75f43
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x75f88
movq 0x8(%r14,%r15,8), %rdi
incq %r15
testq %rdi, %rdi
jne 0x72e6f
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x75f43
// File: /workspace/github_c_makefile_star2_O3/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 0x72efe
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x72ee5
leaq 0x8(%rbx), %r15
leaq 0x7d42e(%rip), %r14     # 0xf02fa
movq %r14, %rsi
movl $0x68, %edx
callq 0x35c27
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x72ecc
leaq 0x7d40e(%rip), %rsi     # 0xf02fa
movq %rbx, %rdi
movl $0x69, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x35c27
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x72fb6
movq %rsi, %r14
testq %rsi, %rsi
je 0x72fb6
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, (%rsi)
movq (%rdi), %rdi
callq 0x77dfe
testq %rax, %rax
je 0x72f93
cmpq $0x0, (%rax)
jne 0x72fc0
movq %r14, %rdi
callq 0x728c0
movq %rsp, %rsi
movq %rax, (%rsi)
movq (%rbx), %rdi
callq 0x77e8a
cmpl $0x1, %eax
jne 0x72fbb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a17d
callq 0x1a1eb
callq 0x1a1b4
// File: /workspace/github_c_makefile_star2_O3/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 0x72fed
testq %rsi, %rsi
je 0x72fed
movq (%rdi), %rdi
movq %rsp, %rsi
callq 0x77dfe
testq %rax, %rax
je 0x72fe9
movq (%rax), %rax
jmp 0x72feb
xorl %eax, %eax
popq %rcx
retq
callq 0x1a222
// File: /workspace/github_c_makefile_star2_O3/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 0x73031
movq %rdi, %r14
callq 0x3c8cc
movq %rax, %rbx
movq (%r14), %rdi
leaq 0x2b(%rip), %rsi        # 0x7303b
leaq 0xfd09(%rip), %rcx      # 0x82d20
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x78322
testl %eax, %eax
jne 0x73036
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a290
callq 0x1a259
// File: /workspace/github_c_makefile_star2_O3/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 0x73056
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0x7307a
testq %r14, %r14
je 0x73075
testq %rbx, %rbx
je 0x73075
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3c9a5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a2fe
callq 0x1a2c7
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
testq %rdi, %rdi
je 0x730d6
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x7326e
leaq 0x7d275(%rip), %rsi     # 0xf0352
movl $0x8, %edi
movl $0x27, %edx
callq 0x35862
movq %rax, %rbx
movups 0xdc682(%rip), %xmm0    # 0x14f778
movups %xmm0, 0x20(%rsp)
movups 0xdc666(%rip), %xmm0    # 0x14f768
movups %xmm0, 0x10(%rsp)
movups 0xdc64a(%rip), %xmm0    # 0x14f758
movups %xmm0, (%rsp)
callq 0x77ca4
movq %rax, (%rbx)
leaq 0x7eac0(%rip), %rsi     # 0xf1be1
movq %rbx, %rdi
callq 0x72fc5
testq %rax, %rax
je 0x73155
leaq 0x70024(%rip), %rsi     # 0xe3159
leaq 0x7d2d5(%rip), %rdx     # 0xf0411
leaq 0x7d2b6(%rip), %rcx     # 0xf03f9
leaq 0x7d208(%rip), %r8      # 0xf0352
movq %r14, %rdi
movl $0x68, %r9d
jmp 0x731a6
leaq 0x7ea85(%rip), %r15     # 0xf1be1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72f66
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72fc5
movq %rax, %rdi
movq %r15, %rsi
callq 0xb890
testl %eax, %eax
je 0x731dd
leaq 0x6ffd1(%rip), %rsi     # 0xe3159
leaq 0x7d2a3(%rip), %rdx     # 0xf0432
leaq 0x7d263(%rip), %rcx     # 0xf03f9
leaq 0x7d1b5(%rip), %r8      # 0xf0352
movq %r14, %rdi
movl $0x6b, %r9d
xorl %eax, %eax
callq 0x34f1f
movq %rbx, %rdi
callq 0x72ff2
movq %rax, %r15
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0x3cc00
movq %rbx, %rdi
callq 0x73273
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x72ff2
movq %rax, %r15
movq %rax, %rdi
callq 0x3cbed
cmpq $0x1, %rax
jne 0x7323d
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
callq 0x3ca6f
leaq 0x7e9d7(%rip), %rsi     # 0xf1be1
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
je 0x731be
leaq 0x6ff3c(%rip), %rsi     # 0xe3159
leaq 0x7d25a(%rip), %rdx     # 0xf047e
leaq 0x7d1ce(%rip), %rcx     # 0xf03f9
leaq 0x7d120(%rip), %r8      # 0xf0352
movq %r14, %rdi
movl $0x6e, %r9d
jmp 0x73262
leaq 0x6ff15(%rip), %rsi     # 0xe3159
leaq 0x7d217(%rip), %rdx     # 0xf0462
leaq 0x7d1a7(%rip), %rcx     # 0xf03f9
leaq 0x7d0f9(%rip), %r8      # 0xf0352
movq %r14, %rdi
movl $0x6d, %r9d
xorl %eax, %eax
callq 0x34f1f
jmp 0x731b8
callq 0x1a3a3
// File: /workspace/github_c_makefile_star2_O3/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 0x7d21d(%rip), %rdx     # 0xf04c4
movl $0x1, %edi
movl $0x28, %esi
movl $0x31, %ecx
callq 0x359a6
testq %rbx, %rbx
leaq 0xd(%rip), %rcx         # 0x732d2
cmoveq %rbx, %rcx
movq %rcx, (%rax)
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7d1df(%rip), %rdx     # 0xf04c4
movl $0x1, %edi
movl $0x28, %esi
movl $0x3c, %ecx
callq 0x359a6
movq %r14, (%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7337f
movq %rdi, %r15
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x7336e
movq %rsi, %r14
movq 0x10(%rbx), %r12
movq (%r15), %rax
testq %rax, %rax
je 0x73360
movq 0x18(%r15), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
je 0x73370
cmpq %r14, %r12
je 0x73370
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x73344
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1a448
// File: /workspace/github_c_makefile_star2_O3/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 0x7356c
testq %rsi, %rsi
je 0x7356c
movq (%rsi), %rax
testq %rax, %rax
je 0x73516
cmpq %rsi, 0x8(%rax)
jne 0x73571
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x73524
cmpq %rsi, (%rcx)
jne 0x73576
testq %rax, %rax
je 0x73531
movq %rcx, 0x8(%rax)
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x73539
movq %rax, (%rcx)
cmpq %rsi, 0x8(%rdi)
jne 0x73543
movq %rcx, 0x8(%rdi)
cmpq %rsi, 0x10(%rdi)
jne 0x73550
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
decq 0x20(%rdi)
leaq 0x7cf69(%rip), %rax     # 0xf04c4
movq %rsi, %rdi
movq %rax, %rsi
movl $0xad, %edx
popq %rax
jmp 0x35c27
callq 0x1a6e8
callq 0x1a721
callq 0x1a75a
// File: /workspace/github_c_makefile_star2_O3/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 0x73595
callq 0x34fea
testb %al, %al
jne 0x735fc
leaq 0x7cf28(%rip), %rdx     # 0xf04c4
movl $0x1, %edi
movl $0x28, %esi
movl $0x31, %ecx
callq 0x359a6
movq %rax, %rbx
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x18(%rbx)
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x733b1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x733b1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x733b1
movq %rbx, %rdi
callq 0x73308
movq %rbx, %rdi
callq 0x73601
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a793
// File: /workspace/github_c_makefile_star2_O3/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 0x73664
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x73637
leaq 0x7cea6(%rip), %r14     # 0xf04c4
movq (%r15), %rdi
movq %r14, %rsi
movl $0x173, %edx            # imm = 0x173
callq 0x35c27
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x7361e
movq 0x10(%rbx), %rdi
leaq 0x7ce82(%rip), %r14     # 0xf04c4
movq %r14, %rsi
movl $0x176, %edx            # imm = 0x176
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x177, %edx            # imm = 0x177
popq %rbx
popq %r14
popq %r15
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x74197
testq %rdx, %rdx
je 0x74197
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
jae 0x7416b
testq %rax, %rax
je 0x74170
testq %rax, %rax
leaq (%rax,%rax), %rax
movq $-0x1, %r14
cmovnsq %rax, %r14
cmpq %rdx, %r14
jb 0x74152
jmp 0x74178
movq %rdi, %rax
jmp 0x7418f
movq %rdx, %r14
testq %rdi, %rdi
jne 0x7419c
leaq 0x7c6d7(%rip), %rdx     # 0xf0856
movq %r14, %rsi
movl $0x2c, %ecx
callq 0x35a9d
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a877
callq 0x1a8ae
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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, 0xdea23(%rip)     # 0x152bd0
jne 0x7422c
leaq 0x7c6cf(%rip), %rdx     # 0xf0885
movl $0x1, %edi
movl $0x38, %esi
movl $0x59, %ecx
callq 0x359a6
movq %rax, 0xde9ff(%rip)     # 0x152bd0
callq 0x3cff6
movq 0xde9f3(%rip), %rcx     # 0x152bd0
movq %rax, (%rcx)
callq 0x3cff6
movq 0xde9e4(%rip), %rcx     # 0x152bd0
movq %rax, 0x8(%rcx)
leaq 0x3a(%rip), %rdx        # 0x74231
xorl %edi, %edi
xorl %esi, %esi
callq 0x7740c
movq 0xde9c9(%rip), %rcx     # 0x152bd0
movq %rax, 0x10(%rcx)
leaq 0x30(%rip), %rdx        # 0x74242
xorl %edi, %edi
xorl %esi, %esi
callq 0x7740c
movq 0xde9ae(%rip), %rcx     # 0x152bd0
movq %rax, 0x18(%rcx)
movb $0x0, 0x30(%rcx)
popq %rax
retq
callq 0x1a8e5
// File: /workspace/github_c_makefile_star2_O3/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 0x7427b
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x742bf
testq %r13, %r13
je 0x742b5
testq %r12, %r12
je 0x742b5
movq 0xde944(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x742ba
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x742c4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1a955
callq 0x1a98e
callq 0x1a91c
// File: /workspace/github_c_makefile_star2_O3/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 0x742fe
callq 0x34fea
testb %al, %al
jne 0x743e8
movl 0x50(%rsp), %r15d
leaq 0x7c57b(%rip), %rsi     # 0xf0885
movl $0x10, %edi
movl $0x6b, %edx
callq 0x35862
movq %rax, %r14
movq %r13, (%rax)
movl %r15d, 0x8(%rax)
movq %r12, %rdi
cmpl $0x2, %ebx
je 0x74341
cmpl $0x1, %ebx
jne 0x74352
testb %bpl, %bpl
je 0x74363
movq 0x8(%rsp), %rsi
callq 0x833b4
jmp 0x74394
testb %bpl, %bpl
je 0x74374
movq 0x8(%rsp), %rsi
callq 0x830e0
jmp 0x74394
testb %bpl, %bpl
je 0x74385
movq 0x8(%rsp), %rsi
callq 0x3d286
jmp 0x74394
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xa44cc
jmp 0x74394
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xa4468
jmp 0x74394
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xa4404
movq %rax, %r15
testq %rax, %rax
je 0x743c2
movq 0x10(%rsp), %rbx
movq (%rbx), %rdi
callq 0x3d043
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x77628
movq (%rbx), %rdi
callq 0x3d05e
jmp 0x743d6
leaq 0x7c4bc(%rip), %rsi     # 0xf0885
movq %r14, %rdi
movl $0x80, %edx
callq 0x35c27
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a9c7
// File: /workspace/github_c_makefile_star2_O3/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 0x74425
movq %rdx, %r9
movq %rsi, %rdx
testq %rsi, %rsi
je 0x74425
movq %rdi, %rsi
movq 0xde7c8(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x7442a
movl %ecx, %eax
xorl %ecx, %ecx
movl $0x1, %r8d
pushq $0x0
pushq %rax
callq 0x742c4
addq $0x10, %rsp
popq %rcx
retq
callq 0x1a9fe
callq 0x1aa37
// File: /workspace/github_c_makefile_star2_O3/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 0x7445d
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x744ab
movq %r13, %rdi
callq 0x3b785
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x3b7af
movq %r13, %rdi
callq 0x3bb5d
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x74253
movq %rax, %rbx
movq %r13, %rdi
callq 0x3c87b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1aa70
// File: /workspace/github_c_makefile_star2_O3/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 0x3d043
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
je 0x7452d
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x77666
movq (%r14), %rdi
callq 0x3d05e
movq %rbx, %rdi
cmpl $0x2, %ebp
je 0x7451b
cmpl $0x1, %ebp
jne 0x74524
popq %rbx
popq %r14
popq %rbp
jmp 0x99890
popq %rbx
popq %r14
popq %rbp
jmp 0x996bb
popq %rbx
popq %r14
popq %rbp
jmp 0xb690
callq 0x1aae2
// File: /workspace/github_c_makefile_star2_O3/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 0x3d043
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
je 0x745af
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x77666
movq (%r14), %rdi
callq 0x3d05e
movq %rbx, %rdi
cmpl $0x2, %ebp
je 0x7459d
cmpl $0x1, %ebp
jne 0x745a6
popq %rbx
popq %r14
popq %rbp
jmp 0x834b2
popq %rbx
popq %r14
popq %rbp
jmp 0x996bb
popq %rbx
popq %r14
popq %rbp
jmp 0x3d1f5
callq 0x1ab54
// File: /workspace/github_c_makefile_star2_O3/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 0x74620
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x74667
testq %r13, %r13
je 0x7465d
testq %r12, %r12
je 0x7465d
movq 0xde59f(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x74662
movq %r13, %rsi
movq %r12, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r14
pushq %rbx
callq 0x742c4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1ac38
callq 0x1ac71
callq 0x1abff
// File: /workspace/github_c_makefile_star2_O3/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 0x746a7
movq %rdx, %r9
movq %rsi, %rdx
testq %rsi, %rsi
je 0x746a7
movq %rdi, %rsi
movq 0xde549(%rip), %rdi     # 0x152bd0
testq %rdi, %rdi
je 0x746ac
movl %ecx, %eax
movl $0x1, %ecx
movl $0x1, %r8d
pushq $0x0
pushq %rax
callq 0x742c4
addq $0x10, %rsp
popq %rcx
retq
callq 0x1acaa
callq 0x1ace3