LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x13ae6f(%rip)    # 0x1b6490
jne 0x7b634
movl $0x8, %edi
callq 0x75ab0
movq %rax, 0x13ae5c(%rip)    # 0x1b6490
movq 0x10(%rsp), %rsi
movl $0x1, %edi
leaq 0xf1dab(%rip), %rdx     # 0x16d3f0
movl $0x1d, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x13ae35(%rip), %rdi    # 0x1b6490
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
cmpq $0x0, 0x13ae04(%rip)    # 0x1b6490
jne 0x7b690
jmp 0x7b708
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x13ade6(%rip), %rdi    # 0x1b6490
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x7b6f1
movq 0x13adcd(%rip), %rdi    # 0x1b6490
movq 0x10(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
leaq 0xf1d19(%rip), %rsi     # 0x16d3f0
movl $0x27, %edx
callq 0xdab0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x7b699
movq 0x13ad98(%rip), %rdi    # 0x1b6490
callq 0x770a0
movq $0x0, 0x13ad88(%rip) # 0x1b6490
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/combinatorics.c
// Function: init_ln_n_fac_tab
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 %rax
cmpq $0x0, 0x13ac97(%rip)    # 0x1b64a0
jne 0x7b8d3
movl $0x43, %edi
movl $0x8, %esi
leaq 0xf1c55(%rip), %rdx     # 0x16d475
movl $0x2c, %ecx
callq 0xd5b0
movq %rax, 0x13ac6f(%rip)    # 0x1b64a0
movsd 0xe2fcf(%rip), %xmm0    # 0x15e808
callq 0xb4b0
movq 0x13ac5b(%rip), %rax    # 0x1b64a0
movsd %xmm0, (%rax)
movq $0x1, (%rsp)
cmpq $0x42, (%rsp)
ja 0x7b8b6
movaps 0xe2c21(%rip), %xmm1    # 0x15e480
movq (%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xe2c20(%rip), %xmm1    # 0x15e490
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0xb4b0
movq 0x13ac15(%rip), %rax    # 0x1b64a0
movq (%rsp), %rcx
subq $0x1, %rcx
addsd (%rax,%rcx,8), %xmm0
movq 0x13ac01(%rip), %rax    # 0x1b64a0
movq (%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x7b851
movq 0x13abe3(%rip), %rax    # 0x1b64a0
movsd 0x210(%rax), %xmm0
leaq 0xf1c5a(%rip), %rdi     # 0x16d526
movb $0x1, %al
callq 0xc930
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq 0x13a7b8(%rip), %rdi    # 0x1b64a0
leaq 0xf1786(%rip), %rsi     # 0x16d475
movl $0x56, %edx
callq 0xdab0
movq $0x0, 0x13a79c(%rip) # 0x1b64a0
movq 0x13a79d(%rip), %rax    # 0x1b64a8
movq (%rax), %rdi
leaq 0xf1760(%rip), %rsi     # 0x16d475
movl $0x58, %edx
callq 0xdab0
movq 0x13a782(%rip), %rdi    # 0x1b64a8
leaq 0xf1748(%rip), %rsi     # 0x16d475
movl $0x58, %edx
callq 0xdab0
movq $0x0, 0x13a766(%rip) # 0x1b64a8
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, (%rsp)
je 0x7bd9f
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
ja 0x7bdad
movq $0x1, 0x10(%rsp)
jmp 0x7be8a
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jae 0x7bdc6
movq $0x0, 0x10(%rsp)
jmp 0x7be8a
jmp 0x7bdc8
cmpq $0x42, 0x8(%rsp)
jbe 0x7be08
movq 0x138201(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe2285(%rip), %rsi     # 0x15e066
leaq 0xf16a6(%rip), %rdx     # 0x16d48e
leaq 0xf16b9(%rip), %rcx     # 0x16d4a8
leaq 0xf167f(%rip), %r8      # 0x16d475
movl $0x67, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7be0a
movq 0x8(%rsp), %rax
shrq %rax
cmpq (%rsp), %rax
jae 0x7be25
movq 0x8(%rsp), %rax
subq (%rsp), %rax
movq %rax, (%rsp)
movq 0x13a674(%rip), %rax    # 0x1b64a0
movq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x13a663(%rip), %rax    # 0x1b64a0
movq (%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq 0x13a653(%rip), %rax    # 0x1b64a0
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
callq 0xbb30
callq 0x8c920
movq %rax, %rdi
leaq 0xf1606(%rip), %rsi     # 0x16d475
movl $0x6d, %edx
leaq 0x1a3c5(%rip), %rcx     # 0x96240
xorl %eax, %eax
movl %eax, %r8d
callq 0x965c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x7bec8
movq $0x0, 0x20(%rsp)
jmp 0x7bfd2
cmpq $0x0, 0x10(%rsp)
je 0x7bedc
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x7beea
movq $0x1, 0x20(%rsp)
jmp 0x7bfd2
jmp 0x7beec
cmpq $0x3e, 0x18(%rsp)
jbe 0x7bf2c
movq 0x1380dd(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe2161(%rip), %rsi     # 0x15e066
leaq 0xf15b9(%rip), %rdx     # 0x16d4c5
leaq 0xf15c9(%rip), %rcx     # 0x16d4dc
leaq 0xf155b(%rip), %r8      # 0x16d475
movl $0x78, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7bf2e
movq 0x18(%rsp), %rax
shrq %rax
cmpq 0x10(%rsp), %rax
jae 0x7bf4c
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq $0x2, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x7bfc9
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
subq 0x10(%rsp), %rsi
addq 0x8(%rsp), %rsi
leaq 0xf14e8(%rip), %rdx     # 0x16d475
movl $0x7f, %ecx
leaq 0x1a2a7(%rip), %r8      # 0x96240
xorl %eax, %eax
movl %eax, %r9d
callq 0x96430
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x7bf67
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x7c041
movq 0x30(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x7c009
jmp 0x7c041
movq 0x137fc8(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe204c(%rip), %rsi     # 0x15e066
leaq 0xe2627(%rip), %rdx     # 0x15e648
leaq 0xf14d5(%rip), %rcx     # 0x16d4fd
leaq 0xf1446(%rip), %r8      # 0x16d475
movl $0x8f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7c043
movq $0x0, 0x20(%rsp)
cmpq $0x3e, 0x20(%rsp)
ja 0x7c17f
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
shrq %rcx
cmpq %rcx, %rax
ja 0x7c16a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7bd50
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7bea0
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x7c0ea
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x7c0e8
movq 0x30(%rsp), %rdi
leaq 0xe40b9(%rip), %rsi     # 0x160177
leaq 0xf1453(%rip), %rdx     # 0x16d518
leaq 0xf1431(%rip), %rcx     # 0x16d4fd
leaq 0xf13a2(%rip), %r8      # 0x16d475
movl $0x95, %r9d
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
jmp 0x7c0ea
jmp 0x7c0ec
cmpq $0x2f, 0x20(%rsp)
jae 0x7c155
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7bd80
movq %rax, (%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x7c151
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x7c14f
movq 0x30(%rsp), %rdi
leaq 0xe4052(%rip), %rsi     # 0x160177
leaq 0xf13f3(%rip), %rdx     # 0x16d51f
leaq 0xf13ca(%rip), %rcx     # 0x16d4fd
leaq 0xf133b(%rip), %r8      # 0x16d475
movl $0x98, %r9d
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
jmp 0x7c151
jmp 0x7c153
jmp 0x7c155
jmp 0x7c157
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x7c061
jmp 0x7c16c
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x7c04c
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x7c449
movq 0x137bc0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe1c44(%rip), %rsi     # 0x15e066
leaq 0xe463d(%rip), %rdx     # 0x160a66
leaq 0xf1162(%rip), %rcx     # 0x16d592
leaq 0xf113f(%rip), %r8      # 0x16d576
movl $0x3c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7c44b
movq 0x10(%rsp), %rdi
callq 0xb240
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0xf110c(%rip), %rsi     # 0x16d576
movl $0x3e, %edx
callq 0xd2e0
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xb500
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x7c4ee
movq 0x137b1b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe1b9f(%rip), %rsi     # 0x15e066
leaq 0xe4598(%rip), %rdx     # 0x160a66
leaq 0xf10c9(%rip), %rcx     # 0x16d59e
leaq 0xf109a(%rip), %r8      # 0x16d576
movl $0x46, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7c4f0
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
leaq 0xf1076(%rip), %rsi     # 0x16d576
movl $0x47, %edx
callq 0xd2e0
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xb500
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, 0x10(%rsp)
movb %cl, 0xf(%rsp)
movb %al, 0xe(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x7c596
movq 0x137a73(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe1af7(%rip), %rsi     # 0x15e066
leaq 0xe44f0(%rip), %rdx     # 0x160a66
leaq 0xf1030(%rip), %rcx     # 0x16d5ad
leaq 0xf0ff2(%rip), %r8      # 0x16d576
movl $0x50, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7c598
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpb $0x0, (%rax)
je 0x7c5d2
movq (%rsp), %rax
movsbl (%rax), %eax
movsbl 0xf(%rsp), %ecx
cmpl %ecx, %eax
jne 0x7c5c4
movb 0xe(%rsp), %cl
movq (%rsp), %rax
movb %cl, (%rax)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x7c5a1
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7c603
cmpq $0x0, 0x10(%rsp)
jne 0x7c63b
movq 0x1379ce(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe1a52(%rip), %rsi     # 0x15e066
leaq 0xf0f9e(%rip), %rdx     # 0x16d5b9
leaq 0xf0fa2(%rip), %rcx     # 0x16d5c4
leaq 0xf0f4d(%rip), %r8      # 0x16d576
movl $0x5c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7c63d
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x7c67a
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %edi
movq 0x10(%rsp), %rsi
callq 0x1c8f0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x7c646
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7c6d0
movq 0x137939(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe19bd(%rip), %rsi     # 0x15e066
leaq 0xe43b6(%rip), %rdx     # 0x160a66
leaq 0xf0f1a(%rip), %rcx     # 0x16d5d1
leaq 0xf0eb8(%rip), %r8      # 0x16d576
movl $0x64, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7c6d2
movq 0x18(%rsp), %rdi
movsbl 0x17(%rsp), %esi
callq 0xb1f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7c702
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x7c711
movq 0x18(%rsp), %rdi
callq 0xb240
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x7c770
movq 0x137899(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe191d(%rip), %rsi     # 0x15e066
leaq 0xe4316(%rip), %rdx     # 0x160a66
leaq 0xf0e94(%rip), %rcx     # 0x16d5eb
leaq 0xf0e18(%rip), %r8      # 0x16d576
movl $0x6e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7c772
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb240
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rsp), %rcx
movb %al, 0x7(%rsp)
jb 0x7c7c2
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
movsbl 0x1f(%rsp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x7c7cc
jmp 0x7c7de
jmp 0x7c7ce
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x7c79a
movq 0x10(%rsp), %rax
movb $0x0, 0x1(%rax)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x7cb22
movq 0x1374e7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe156b(%rip), %rsi     # 0x15e066
leaq 0xf0b9d(%rip), %rdx     # 0x16d69f
leaq 0xf0ba1(%rip), %rcx     # 0x16d6aa
leaq 0xf0bac(%rip), %r8      # 0x16d6bc
movl $0x1c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7cb24
jmp 0x7cb26
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
cmpq $0x0, (%rax,%rcx,8)
je 0x7cb45
jmp 0x7cb26
movq 0x10(%rsp), %rdi
shlq $0x3, %rdi
leaq 0xf0b67(%rip), %rsi     # 0x16d6bc
movl $0x1e, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x7cbb4
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7c400
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x7cb6d
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x7cbfe
cmpq $0x0, 0x28(%rsp)
jne 0x7cc36
movq 0x1373d3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe1457(%rip), %rsi     # 0x15e066
leaq 0xf0abc(%rip), %rdx     # 0x16d6d2
leaq 0xf0ac5(%rip), %rcx     # 0x16d6e2
leaq 0xf0a98(%rip), %r8      # 0x16d6bc
movl $0x29, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7cc38
movq 0x30(%rsp), %rdi
callq 0x7cd50
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
leaq 0xf0a61(%rip), %rsi     # 0x16d6bc
movl $0x2b, %edx
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xb240
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0xb240
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $0x2, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
shlq $0x0, %rdi
leaq 0xf0a14(%rip), %rsi     # 0x16d6bc
movl $0x2d, %edx
callq 0xd2e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq (%rax), %r8
leaq 0xe243d(%rip), %rdx     # 0x15f11b
movb $0x0, %al
callq 0xb9d0
movq $0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x7cd2e
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7c400
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x7ccee
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/cstr_array.c
// Function: gt_cstr_array_size
GtUword gt_cstr_array_size(const char **cstr_array)
{
  GtUword i = 0;
  while (cstr_array[i])
    i++;
  return i;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7cd7f
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x7cd5e
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7cdae
cmpq $0x0, 0x18(%rsp)
jne 0x7cde6
movq 0x137223(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe12a7(%rip), %rsi     # 0x15e066
leaq 0xf090c(%rip), %rdx     # 0x16d6d2
leaq 0xf0930(%rip), %rcx     # 0x16d6fd
leaq 0xf08e8(%rip), %r8      # 0x16d6bc
movl $0x39, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7cde8
movq 0x20(%rsp), %rdi
callq 0x7cd50
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x2, %rdi
shlq $0x3, %rdi
leaq 0xf08b1(%rip), %rsi     # 0x16d6bc
movl $0x3b, %edx
callq 0xd2e0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x7c400
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x7ce76
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7c400
movq %rax, %rdx
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x7ce36
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq $0x0, 0x8(%rax,%rcx,8)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7cf01
cmpq $0x0, (%rsp)
je 0x7cedc
movq 0x8(%rsp), %rsi
movl $0x20, %edi
callq 0x1c8f0
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x1c930
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x7ceb6
movq 0x8(%rsp), %rsi
movl $0xa, %edi
callq 0x1c8f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7cf81
cmpq $0x0, (%rsp)
je 0x7cf5c
movq 0x8(%rsp), %rsi
movl $0x20, %edi
callq 0x83a70
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x83b40
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x7cf36
movq 0x8(%rsp), %rsi
movl $0xa, %edi
callq 0x83a70
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x7cfbc
jmp 0x7d012
jmp 0x7cfbe
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7cffc
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movq (%rax,%rcx,8), %rdi
leaq 0xf06cc(%rip), %rsi     # 0x16d6bc
movl $0x68, %edx
callq 0xdab0
jmp 0x7cfbe
movq 0x10(%rsp), %rdi
leaq 0xf06b4(%rip), %rsi     # 0x16d6bc
movl $0x69, %edx
callq 0xdab0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/cstr_table.c
// Function: gt_cstr_table_new
GtCstrTable* gt_cstr_table_new()
{
  HashElemInfo cstr_table = {
    gt_ht_cstr_elem_hash, { free_cstr_table_entry }, sizeof (char*),
    gt_ht_cstr_elem_cmp, NULL, NULL };
  GtCstrTable *table = gt_malloc(sizeof (GtCstrTable));
  table->strings = gt_hashtable_new(cstr_table);
  return table;
}

// Assembly:
subq $0x68, %rsp
leaq 0x38(%rsp), %rdi
leaq 0x135b68(%rip), %rsi    # 0x1b2b98
movl $0x30, %edx
callq 0xb500
movl $0x8, %edi
leaq 0xf06ce(%rip), %rsi     # 0x16d714
movl $0x27, %edx
callq 0xd2e0
movq %rax, 0x30(%rsp)
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x87020
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7d0ce
cmpq $0x0, 0x18(%rsp)
jne 0x7d106
movq 0x136f03(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe0f87(%rip), %rsi     # 0x15e066
leaq 0xf0644(%rip), %rdx     # 0x16d72a
leaq 0xf064b(%rip), %rcx     # 0x16d738
leaq 0xf0620(%rip), %r8      # 0x16d714
movl $0x30, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7d108
jmp 0x7d10a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7d1d0
cmpq $0x0, %rax
je 0x7d157
movq 0x136eb2(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe0f36(%rip), %rsi     # 0x15e066
leaq 0xf0613(%rip), %rdx     # 0x16d74a
leaq 0xf05fa(%rip), %rcx     # 0x16d738
leaq 0xf05cf(%rip), %r8      # 0x16d714
movl $0x31, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7d159
movq 0x18(%rsp), %rdi
callq 0x7c400
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x872d0
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
je 0x7d1bd
movq 0x136e4c(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe0ed0(%rip), %rsi     # 0x15e066
leaq 0xe7b02(%rip), %rdx     # 0x164c9f
leaq 0xf0594(%rip), %rcx     # 0x16d738
leaq 0xf0569(%rip), %r8      # 0x16d714
movl $0x34, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7d1bf
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x7d1ee
cmpq $0x0, 0x18(%rsp)
jne 0x7d226
movq 0x136de3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe0e67(%rip), %rsi     # 0x15e066
leaq 0xf0524(%rip), %rdx     # 0x16d72a
leaq 0xf055d(%rip), %rcx     # 0x16d76a
leaq 0xf0500(%rip), %r8      # 0x16d714
movl $0x3a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7d228
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0x87110
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7d256
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x7d25f
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x7d25f
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x7d2b9
movq 0x136d50(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe0dd4(%rip), %rsi     # 0x15e066
leaq 0xeeb95(%rip), %rdx     # 0x16be2e
leaq 0xf04dc(%rip), %rcx     # 0x16d77c
leaq 0xf046d(%rip), %r8      # 0x16d714
movl $0x4d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7d2bb
callq 0x1b020
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x69(%rip), %rsi        # 0x7d340
leaq 0x24c22(%rip), %rcx     # 0xa1f00
xorl %eax, %eax
movl %eax, %r8d
callq 0x87d80
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x7d32b
movq 0x136cde(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe0d62(%rip), %rsi     # 0x15e066
leaq 0xe9cb3(%rip), %rdx     # 0x166fbe
leaq 0xf046a(%rip), %rcx     # 0x16d77c
leaq 0xf03fb(%rip), %r8      # 0x16d714
movl $0x51, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7d32d
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7d3ad
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x7d375
jmp 0x7d3ad
movq 0x136c5c(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe0ce0(%rip), %rsi     # 0x15e066
leaq 0xe12bb(%rip), %rdx     # 0x15e648
leaq 0xf04d9(%rip), %rcx     # 0x16d86d
leaq 0xf0379(%rip), %r8      # 0x16d714
movl $0x43, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7d3af
jmp 0x7d3b1
cmpq $0x0, 0x20(%rsp)
je 0x7d3c1
cmpq $0x0, 0x8(%rsp)
jne 0x7d3f9
movq 0x136c10(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe0c94(%rip), %rsi     # 0x15e066
leaq 0xf049f(%rip), %rdx     # 0x16d878
leaq 0xf048d(%rip), %rcx     # 0x16d86d
leaq 0xf032d(%rip), %r8      # 0x16d714
movl $0x44, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7d3fb
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x1b180
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, %edi
movl $0x28, %esi
leaq 0xf010c(%rip), %rdx     # 0x16d886
movl $0x31, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x7d79f
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0x7d7ae
movq 0x8(%rsp), %rax
leaq 0x25(%rip), %rcx        # 0x7d7d0
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x1, %edi
movl $0x28, %esi
leaq 0xf0067(%rip), %rdx     # 0x16d886
movl $0x3c, %ecx
callq 0xd5b0
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7d93e
movq 0x1366cb(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe074f(%rip), %rsi     # 0x15e066
leaq 0xeff79(%rip), %rdx     # 0x16d897
leaq 0xeff95(%rip), %rcx     # 0x16d8ba
leaq 0xeff5a(%rip), %r8      # 0x16d886
movl $0x52, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7d940
movq 0x18(%rsp), %rdi
callq 0x7d850
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7d9c9
movq 0x8(%rsp), %rdi
callq 0x7d9e0
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x7d99d
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x7d99d
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x7d9d2
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x7d9b4
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x7d9d2
jmp 0x7d9b6
jmp 0x7d9b8
movq 0x8(%rsp), %rdi
callq 0x7da30
movq %rax, 0x8(%rsp)
jmp 0x7d94f
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7df8e
cmpq $0x0, 0x8(%rsp)
jne 0x7dfc6
movq 0x136043(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe00c7(%rip), %rsi     # 0x15e066
leaq 0xef999(%rip), %rdx     # 0x16d93f
leaq 0xef9a5(%rip), %rcx     # 0x16d952
leaq 0xef8d2(%rip), %r8      # 0x16d886
movl $0xa1, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7dfc8
jmp 0x7dfca
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x7e020
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rsp), %rax
je 0x7e020
movq 0x135fe9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe006d(%rip), %rsi     # 0x15e066
leaq 0xef962(%rip), %rdx     # 0x16d962
leaq 0xef94b(%rip), %rcx     # 0x16d952
leaq 0xef878(%rip), %r8      # 0x16d886
movl $0xa2, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7e022
jmp 0x7e024
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7e07b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpq 0x8(%rsp), %rax
je 0x7e07b
movq 0x135f8e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xe0012(%rip), %rsi     # 0x15e066
leaq 0xef946(%rip), %rdx     # 0x16d9a1
leaq 0xef8f0(%rip), %rcx     # 0x16d952
leaq 0xef81d(%rip), %r8      # 0x16d886
movl $0xa3, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7e07d
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x7e09d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7e0bd
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x7e0df
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x7e100
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rdi
leaq 0xef769(%rip), %rsi     # 0x16d886
movl $0xad, %edx
callq 0xdab0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x7c0, 0x4(%rsp)       # imm = 0x7C0
cmpq $0x0, 0x20(%rsp)
je 0x7e191
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x7e159
jmp 0x7e191
movq 0x135e78(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdfefc(%rip), %rsi     # 0x15e066
leaq 0xe04d7(%rip), %rdx     # 0x15e648
leaq 0xef864(%rip), %rcx     # 0x16d9dc
leaq 0xef707(%rip), %r8      # 0x16d886
movl $0xbb, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7e193
xorl %eax, %eax
movl %eax, %edi
callq 0x7d760
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x7dab0
movq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x7dab0
movq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x7dab0
movq 0x10(%rsp), %rdi
callq 0x7d850
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x7e205
movq 0x18(%rsp), %rdi
callq 0x7d9e0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7da30
movq %rax, 0x18(%rsp)
jmp 0x7e1dd
movq 0x10(%rsp), %rdi
callq 0x7e220
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x7e233
jmp 0x7e2a2
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7e272
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0xef62e(%rip), %rsi     # 0x16d886
movl $0x173, %edx            # imm = 0x173
callq 0xdab0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x7e241
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0xef604(%rip), %rsi     # 0x16d886
movl $0x176, %edx            # imm = 0x176
callq 0xdab0
movq 0x10(%rsp), %rdi
leaq 0xef5ee(%rip), %rsi     # 0x16d886
movl $0x177, %edx            # imm = 0x177
callq 0xdab0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
jmp 0x7f4b3
cmpq $0x0, 0x136ff5(%rip)    # 0x1b64b0
je 0x7f4f5
movq 0x134b14(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdeb98(%rip), %rsi     # 0x15e066
leaq 0xee788(%rip), %rdx     # 0x16dc5d
leaq 0xee785(%rip), %rcx     # 0x16dc61
leaq 0xee789(%rip), %r8      # 0x16dc6c
movl $0x58, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7f4f7
movl $0x1, %edi
movl $0x38, %esi
leaq 0xee764(%rip), %rdx     # 0x16dc6c
movl $0x59, %ecx
callq 0xd5b0
movq %rax, 0x136f97(%rip)    # 0x1b64b0
callq 0x1c240
movq %rax, %rcx
movq 0x136f88(%rip), %rax    # 0x1b64b0
movq %rcx, (%rax)
callq 0x1c240
movq %rax, %rcx
movq 0x136f76(%rip), %rax    # 0x1b64b0
movq %rcx, 0x8(%rax)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0x45(%rip), %rdx        # 0x7f590
callq 0x86190
movq %rax, %rcx
movq 0x136f56(%rip), %rax    # 0x1b64b0
movq %rcx, 0x10(%rax)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0x45(%rip), %rdx        # 0x7f5b0
callq 0x86190
movq %rax, %rcx
movq 0x136f36(%rip), %rax    # 0x1b64b0
movq %rcx, 0x18(%rax)
movq 0x136f2b(%rip), %rax    # 0x1b64b0
movb $0x0, 0x30(%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7f63c
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x7f604
jmp 0x7f63c
movq 0x1349cd(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdea51(%rip), %rsi     # 0x15e066
leaq 0xdf02c(%rip), %rdx     # 0x15e648
leaq 0xee657(%rip), %rcx     # 0x16dc7a
leaq 0xee642(%rip), %r8      # 0x16dc6c
movl $0xb5, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7f63e
jmp 0x7f640
cmpq $0x0, 0x30(%rsp)
je 0x7f650
cmpq $0x0, 0x28(%rsp)
jne 0x7f688
movq 0x134981(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xdea05(%rip), %rsi     # 0x15e066
leaq 0xeea1c(%rip), %rdx     # 0x16e084
leaq 0xee60b(%rip), %rcx     # 0x16dc7a
leaq 0xee5f6(%rip), %r8      # 0x16dc6c
movl $0xb6, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7f68a
jmp 0x7f68c
cmpq $0x0, 0x136e1c(%rip)    # 0x1b64b0
jne 0x7f6ce
movq 0x13493b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde9bf(%rip), %rsi     # 0x15e066
leaq 0xee9ed(%rip), %rdx     # 0x16e09b
leaq 0xee5c5(%rip), %rcx     # 0x16dc7a
leaq 0xee5b0(%rip), %r8      # 0x16dc6c
movl $0xb7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7f6d0
movq 0x136dd9(%rip), %rdi    # 0x1b64b0
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r9
movl 0x1c(%rsp), %r10d
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movl %r8d, %ecx
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x7f710
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x7f9d7
cmpq $0x0, 0x28(%rsp)
jne 0x7fa0f
movq 0x1345fa(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde67e(%rip), %rsi     # 0x15e066
leaq 0xee695(%rip), %rdx     # 0x16e084
leaq 0xee295(%rip), %rcx     # 0x16dc8b
leaq 0xee26f(%rip), %r8      # 0x16dc6c
movl $0xbf, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7fa11
jmp 0x7fa13
cmpq $0x0, 0x136a95(%rip)    # 0x1b64b0
jne 0x7fa55
movq 0x1345b4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde638(%rip), %rsi     # 0x15e066
leaq 0xee666(%rip), %rdx     # 0x16e09b
leaq 0xee24f(%rip), %rcx     # 0x16dc8b
leaq 0xee229(%rip), %r8      # 0x16dc6c
movl $0xc0, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7fa57
movq 0x136a52(%rip), %rdi    # 0x1b64b0
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r9
movl 0x1c(%rsp), %eax
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r10d, %r10d
movl %eax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x7f710
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x7fb12
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x7fada
jmp 0x7fb12
movq 0x1344f7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xde57b(%rip), %rsi     # 0x15e066
leaq 0xdeb56(%rip), %rdx     # 0x15e648
leaq 0xee1a4(%rip), %rcx     # 0x16dc9d
leaq 0xee16c(%rip), %r8      # 0x16dc6c
movl $0xcb, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x7fb14
movq 0x40(%rsp), %rdi
callq 0x18f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x18fb0
movq 0x10(%rsp), %rdi
callq 0x19940
movq %rax, %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %r8
callq 0x7f5d0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1afc0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq