LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_example
int gt_bittab_example(GT_UNUSED GtError *err)
{
  GtUword bit;
  GtBittab *b;
  gt_error_check(err);

  b = gt_bittab_new(32);
  gt_bittab_set_bit(b, 8);
  gt_bittab_set_bit(b, 16);
  gt_bittab_set_bit(b, 24);

  /* a typical iterator loop */
  for (bit  = gt_bittab_get_first_bitnum(b);
       bit != gt_bittab_get_last_bitnum(b);
       bit  = gt_bittab_get_next_bitnum(b, bit)) {
    /* ... */
  }

  gt_bittab_delete(b);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4e24f
callq 0xc103
testb %al, %al
jne 0x4e2b2
pushq $0x20
popq %rdi
callq 0x4d6a4
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %rax, %rdi
callq 0x4d737
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x4d737
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x4d737
movq %rbx, %rdi
callq 0x4dfa3
movq %rax, %r14
movq %rbx, %rdi
callq 0x4e012
cmpq %rax, %r14
je 0x4e2a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e055
jmp 0x4e283
movq %rbx, %rdi
callq 0x4e2ea
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xdfcff(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7bda3(%rip), %rsi     # 0xca066
leaq 0x7c38f(%rip), %rdx     # 0xca659
leaq 0x8a89c(%rip), %rcx     # 0xd8b6d
leaq 0x8a542(%rip), %r8      # 0xd881a
movl $0x13d, %r9d            # imm = 0x13D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, 0xe0a48(%rip)     # 0x12fba0
jne 0x4f169
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0xe0a37(%rip)     # 0x12fba0
leaq 0x89e80(%rip), %rdx     # 0xd8ff0
pushq $0x1
popq %rdi
pushq $0x1d
popq %rcx
movq %rbx, %rsi
callq 0xce9a
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq 0xe0a13(%rip), %rdi     # 0x12fba0
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x4b801
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe09f8(%rip), %rdi     # 0x12fba0
testq %rdi, %rdi
je 0x4f200
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
leaq 0x89e36(%rip), %r14     # 0xd8ff0
pushq $0x27
popq %rbp
callq 0x4b988
movq 0xe09d7(%rip), %rdi     # 0x12fba0
cmpq %rax, %rbx
jae 0x4f1ef
movq %rbx, %rsi
callq 0x4b48e
movq (%rax), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xd249
incq %rbx
movq 0xe09b3(%rip), %rdi     # 0x12fba0
jmp 0x4f1bd
callq 0x4c19d
andq $0x0, 0xe09a4(%rip)     # 0x12fba0
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0xe08f4(%rip)     # 0x12fbb0
jne 0x4f31e
leaq 0x89db0(%rip), %rdx     # 0xd9075
pushq $0x43
popq %rdi
pushq $0x8
popq %rsi
pushq $0x2c
popq %rcx
callq 0xce9a
movq %rax, 0xe08d6(%rip)     # 0x12fbb0
andq $0x0, (%rax)
pushq $0x1
popq %rbx
cmpq $0x43, %rbx
je 0x4f308
cvtsi2sd %rbx, %xmm0
callq 0xb4d0
movq 0xe08b8(%rip), %rax     # 0x12fbb0
addsd -0x8(%rax,%rbx,8), %xmm0
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
jmp 0x4f2e1
movsd 0x210(%rax), %xmm0
leaq 0x89e0f(%rip), %rdi     # 0xd9126
movb $0x1, %al
callq 0xc5d2
cmpq $0x0, 0xe0892(%rip)     # 0x12fbb8
je 0x4f32d
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %r14
leaq 0x89d3d(%rip), %rbx     # 0xd9075
pushq $0x3c
popq %rbp
movl $0x220, %edi            # imm = 0x220
movq %rbx, %rsi
movl %ebp, %edx
callq 0xccb0
movq %rax, 0xe0867(%rip)     # 0x12fbb8
movl $0x4840, %edi           # imm = 0x4840
movq %rbx, %rsi
movl %ebp, %edx
callq 0xccb0
movq 0xe0851(%rip), %rcx     # 0x12fbb8
movq %rax, (%rcx)
movl $0x110, %eax            # imm = 0x110
cmpq $0x44, %r14
je 0x4f386
movq -0x8(%rcx,%r14,8), %rdx
addq %rax, %rdx
movq %rdx, (%rcx,%r14,8)
incq %r14
jmp 0x4f36f
movq (%rcx), %rax
pushq $0x1
popq %rdx
cmpq $0x22, %rdx
je 0x4f39c
andq $0x0, (%rax,%rdx,8)
incq %rdx
jmp 0x4f38c
xorl %eax, %eax
cmpq $0x44, %rax
je 0x4f3b4
movq (%rcx,%rax,8), %rdx
movq $0x1, (%rdx)
incq %rax
jmp 0x4f39e
pushq $0x1
popq %rax
movq %rax, %rdx
cmpq $0x44, %rdx
je 0x4f328
movq %rax, %rsi
cmpq $0x22, %rsi
je 0x4f3ff
movq %rax, %rdi
cmpq %rsi, %rdx
jbe 0x4f3f2
movq -0x8(%rcx,%rdx,8), %rdi
movq -0x8(%rdi,%rsi,8), %r8
movq (%rdi,%rsi,8), %rdi
testq %rdi, %rdi
je 0x4f3ef
addq %r8, %rdi
jae 0x4f3f2
jmp 0x4f404
movq %r8, %rdi
movq (%rcx,%rdx,8), %r8
movq %rdi, (%r8,%rsi,8)
incq %rsi
jmp 0x4f3c7
incq %rdx
jmp 0x4f3ba
movq 0xdebad(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x89d21(%rip), %rsi     # 0xd9136
leaq 0x89c59(%rip), %rdx     # 0xd9075
pushq $0x48
popq %rcx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq 0xe0778(%rip), %rdi     # 0x12fbb0
leaq 0x89c36(%rip), %rbx     # 0xd9075
pushq $0x56
popq %rdx
movq %rbx, %rsi
callq 0xd249
andq $0x0, 0xe075e(%rip)     # 0x12fbb0
movq 0xe075f(%rip), %rax     # 0x12fbb8
movq (%rax), %rdi
pushq $0x58
popq %rbp
movq %rbx, %rsi
movl %ebp, %edx
callq 0xd249
movq 0xe0748(%rip), %rdi     # 0x12fbb8
movq %rbx, %rsi
movl %ebp, %edx
callq 0xd249
andq $0x0, 0xe0736(%rip)     # 0x12fbb8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4f500
cmpq $0x43, %rdi
jae 0x4f505
movq %rdi, %rcx
shrq %rcx
cmpq %rsi, %rcx
cmovaeq %rsi, %rax
movq 0xe06e9(%rip), %rcx     # 0x12fbb0
movsd (%rcx,%rdi,8), %xmm0
subsd (%rcx,%rax,8), %xmm0
subq %rax, %rdi
subsd (%rcx,%rdi,8), %xmm0
callq 0xbb60
callq 0x590f8
leaq 0x89b8b(%rip), %rsi     # 0xd9075
leaq 0xef43(%rip), %rcx      # 0x5e434
pushq $0x6d
popq %rdx
movq %rax, %rdi
xorl %r8d, %r8d
popq %rax
jmp 0x5e53e
pushq $0x1
popq %rax
popq %rcx
retq
movq 0xdeaac(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7ab50(%rip), %rsi     # 0xca066
leaq 0x89b71(%rip), %rdx     # 0xd908e
leaq 0x89b84(%rip), %rcx     # 0xd90a8
leaq 0x89b4a(%rip), %r8      # 0xd9075
pushq $0x67
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
jae 0x4f54f
xorl %eax, %eax
jmp 0x4f568
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
movq %rdi, %r12
subq %rsi, %r12
sete %cl
orb %al, %cl
je 0x4f577
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x3f, %rbx
jae 0x4f5cc
movq %rbx, %rax
shrq %rax
cmpq %rsi, %rax
cmovaeq %rsi, %r12
subq %r12, %rbx
leaq 0x1(%rbx), %rax
pushq $0x2
popq %r13
leaq 0x89ad9(%rip), %r14     # 0xd9075
leaq 0xee91(%rip), %r15      # 0x5e434
pushq $0x7f
popq %rbp
cmpq %r12, %r13
ja 0x4f568
leaq (%rbx,%r13), %rsi
movq %rax, %rdi
movq %r14, %rdx
movl %ebp, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x5e493
xorl %edx, %edx
divq %r13
incq %r13
jmp 0x4f5a6
movq 0xde9e5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7aa89(%rip), %rsi     # 0xca066
leaq 0x89ae1(%rip), %rdx     # 0xd90c5
leaq 0x89af1(%rip), %rcx     # 0xd90dc
leaq 0x89a83(%rip), %r8      # 0xd9075
pushq $0x78
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4f625
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x4f72a
movq %rbx, (%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
cmpq $0x3f, %rbp
je 0x4f718
movq %rbp, %r13
shrq %r13
incq %r13
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x4f710
movq 0xe0564(%rip), %rax     # 0x12fbb8
movq (%rax,%rbp,8), %rax
movq (%rax,%r15,8), %rbx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x4f53b
xorl %r12d, %r12d
testl %r14d, %r14d
pushq $-0x1
popq %r14
jne 0x4f6b5
movb $0x1, %r12b
movl $0x0, %r14d
cmpq %rax, %rbx
je 0x4f6b5
xorl %r12d, %r12d
movq (%rsp), %rdi
leaq 0x7caca(%rip), %rsi     # 0xcc159
leaq 0x89a82(%rip), %rdx     # 0xd9118
leaq 0x89a60(%rip), %rcx     # 0xd90fd
leaq 0x899d1(%rip), %r8      # 0xd9075
movl $0x95, %r9d
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %r14
cmpq $0x2e, %rbp
ja 0x4f708
movq %rbp, %rdi
movq %r15, %rsi
callq 0x4f499
pushq $-0x1
popq %r14
testb %r12b, %r12b
je 0x4f708
xorl %r14d, %r14d
cmpq %rbx, %rax
je 0x4f708
movq (%rsp), %rdi
leaq 0x7ca77(%rip), %rsi     # 0xcc159
leaq 0x89a36(%rip), %rdx     # 0xd911f
leaq 0x89a0d(%rip), %rcx     # 0xd90fd
leaq 0x8997e(%rip), %r8      # 0xd9075
movl $0x98, %r9d
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %r14
incq %r15
jmp 0x4f644
incq %rbp
jmp 0x4f62e
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xde887(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a92b(%rip), %rsi     # 0xca066
leaq 0x7af17(%rip), %rdx     # 0xca659
leaq 0x899b4(%rip), %rcx     # 0xd90fd
leaq 0x89925(%rip), %r8      # 0xd9075
movl $0x8f, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
testq %rdi, %rdi
je 0x4f84e
movl %esi, %ebx
movq %rdi, %r14
callq 0xb260
xorl %ebp, %ebp
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x4f79c
xorl %edx, %edx
cmpb %bl, (%r14,%rcx)
sete %dl
addq %rdx, %rbp
incq %rcx
jmp 0x4f786
leaq 0x2(%rbp), %rdi
leaq 0x899bd(%rip), %rdx     # 0xd9164
pushq $0x8
popq %rsi
pushq $0x28
popq %rcx
callq 0xce9a
movq %rax, (%rsp)
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r12, %r13
movq %r14, %rdi
callq 0xb260
incq %rax
cmpq %rax, %r13
jae 0x4f82e
movb (%r14,%r13), %cl
cmpb %bl, %cl
je 0x4f7e0
testb %cl, %cl
je 0x4f7e0
incq %r13
jmp 0x4f7ca
testq %r13, %r13
je 0x4f808
movq %r13, %rdi
subq %r12, %rdi
incq %rdi
pushq $0x1
popq %rsi
leaq 0x8996c(%rip), %rdx     # 0xd9164
pushq $0x2c
popq %rcx
callq 0xce9a
movq (%rsp), %rcx
movq %rax, (%rcx,%r15,8)
movq %r13, %rdx
subq %r12, %rdx
je 0x4f823
movq (%rsp), %rax
movq (%rax,%r15,8), %rdi
addq %r14, %r12
movq %r12, %rsi
callq 0xb520
incq %r13
incq %r15
movq %r13, %r12
jmp 0x4f7bf
incq %rbp
cmpq %rbp, %r15
jne 0x4f878
movq (%rsp), %rax
andq $0x0, (%rax,%r15,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xde763(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a807(%rip), %rsi     # 0xca066
leaq 0x7d1df(%rip), %rdx     # 0xcca45
leaq 0x898e9(%rip), %rcx     # 0xd9156
leaq 0x898f0(%rip), %r8      # 0xd9164
pushq $0x21
jmp 0x4f8a0
movq 0xde739(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a7dd(%rip), %rsi     # 0xca066
leaq 0x898e4(%rip), %rdx     # 0xd9174
leaq 0x898bf(%rip), %rcx     # 0xd9156
leaq 0x898c6(%rip), %r8      # 0xd9164
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4f8ea
movq %rdi, %rbx
callq 0xb260
leaq 0x1(%rax), %r14
leaq 0x8989a(%rip), %rsi     # 0xd9164
pushq $0x3e
popq %rdx
movq %r14, %rdi
callq 0xccb0
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb520
movq 0xde6c7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a76b(%rip), %rsi     # 0xca066
leaq 0x7d143(%rip), %rdx     # 0xcca45
leaq 0x89877(%rip), %rcx     # 0xd9180
leaq 0x89854(%rip), %r8      # 0xd9164
pushq $0x3c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4f962
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
leaq 0x89829(%rip), %rsi     # 0xd9164
pushq $0x47
popq %rdx
callq 0xccb0
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
movq 0xde64f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a6f3(%rip), %rsi     # 0xca066
leaq 0x7d0cb(%rip), %rdx     # 0xcca45
leaq 0x8980b(%rip), %rcx     # 0xd918c
leaq 0x897dc(%rip), %r8      # 0xd9164
pushq $0x46
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
jne 0x4f9de
movq 0xde613(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a6b7(%rip), %rsi     # 0xca066
leaq 0x7d08f(%rip), %rdx     # 0xcca45
leaq 0x897de(%rip), %rcx     # 0xd919b
leaq 0x897a0(%rip), %r8      # 0xd9164
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
cmpb %sil, %al
jne 0x4f9db
movb %dl, (%rdi)
incq %rdi
movb (%rdi), %al
testb %al, %al
jne 0x4f9d4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4fa27
movq %rdx, %rbx
testq %rdx, %rdx
je 0x4fa27
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x4fa1b
movsbl (%r15,%r12), %edi
movq %rbx, %rsi
callq 0x1640e
incq %r12
jmp 0x4fa04
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xde58a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a62e(%rip), %rsi     # 0xca066
leaq 0x89768(%rip), %rdx     # 0xd91a7
leaq 0x8976c(%rip), %rcx     # 0xd91b2
leaq 0x89717(%rip), %r8      # 0xd9164
pushq $0x5c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4fa82
movq %rdi, %rbx
movsbl %sil, %esi
callq 0xb210
testq %rax, %rax
je 0x4fa79
subq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0xb260
movq 0xde52f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a5d3(%rip), %rsi     # 0xca066
leaq 0x7cfab(%rip), %rdx     # 0xcca45
leaq 0x8971e(%rip), %rcx     # 0xd91bf
leaq 0x896bc(%rip), %r8      # 0xd9164
pushq $0x64
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4faf0
movl %esi, %ebp
movq %rdi, %rbx
callq 0xb260
leaq (%rax,%rbx), %rcx
decq %rcx
movq %rcx, %rax
cmpq %rbx, %rcx
jb 0x4fae2
leaq -0x1(%rax), %rcx
cmpb %bpl, (%rax)
je 0x4fad1
movb $0x0, 0x1(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xde4c1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a565(%rip), %rsi     # 0xca066
leaq 0x7cf3d(%rip), %rdx     # 0xcca45
leaq 0x896ca(%rip), %rcx     # 0xd91d9
leaq 0x8964e(%rip), %r8      # 0xd9164
pushq $0x6e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4fb45
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x4fce1
leaq 0x8969b(%rip), %rdi     # 0xd91e7
pushq $0x20
popq %rsi
callq 0x4f764
movq %rax, %r14
movq (%rax), %rdi
leaq 0x8b3a0(%rip), %rsi     # 0xdaf01
callq 0xb880
testl %eax, %eax
je 0x4fb90
leaq 0x7c5e8(%rip), %rsi     # 0xcc159
leaq 0x8968e(%rip), %rdx     # 0xd9206
leaq 0x89675(%rip), %rcx     # 0xd91f4
leaq 0x895de(%rip), %r8      # 0xd9164
xorl %r15d, %r15d
pushq $0x7c
jmp 0x4fc2c
movq 0x8(%r14), %rax
cmpb $0x0, (%rax)
je 0x4fbbc
leaq 0x7c5b9(%rip), %rsi     # 0xcc159
leaq 0x8967a(%rip), %rdx     # 0xd9221
leaq 0x89646(%rip), %rcx     # 0xd91f4
leaq 0x895af(%rip), %r8      # 0xd9164
xorl %r15d, %r15d
pushq $0x7d
jmp 0x4fc2c
movq 0x10(%r14), %rdi
leaq 0x8a660(%rip), %rsi     # 0xda227
callq 0xb880
testl %eax, %eax
je 0x4fbf3
leaq 0x7c582(%rip), %rsi     # 0xcc159
leaq 0x8965b(%rip), %rdx     # 0xd9239
leaq 0x8960f(%rip), %rcx     # 0xd91f4
leaq 0x89578(%rip), %r8      # 0xd9164
xorl %r15d, %r15d
pushq $0x7e
jmp 0x4fc2c
movq 0x18(%r14), %rdi
leaq 0x895f2(%rip), %rsi     # 0xd91f0
callq 0xb880
testl %eax, %eax
je 0x4fca5
leaq 0x7c547(%rip), %rsi     # 0xcc159
leaq 0x8963b(%rip), %rdx     # 0xd9254
leaq 0x895d4(%rip), %rcx     # 0xd91f4
leaq 0x8953d(%rip), %r8      # 0xd9164
xorl %r15d, %r15d
pushq $0x7f
popq %r9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc007
movq %r14, %rdi
callq 0x5000b
leaq 0x87e98(%rip), %rdi     # 0xd7adf
pushq $0x20
popq %rsi
callq 0x4f764
movq %rax, %r14
pushq $-0x1
popq %rbp
testb %r15b, %r15b
je 0x4fc90
cmpq $0x0, (%r14)
je 0x4fc8e
leaq 0x7c4f2(%rip), %rsi     # 0xcc159
leaq 0x89610(%rip), %rdx     # 0xd927e
leaq 0x8957f(%rip), %rcx     # 0xd91f4
leaq 0x894e8(%rip), %r8      # 0xd9164
movq %rbx, %rdi
movl $0x84, %r9d
xorl %eax, %eax
callq 0xc007
jmp 0x4fc90
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x5000b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x20(%r14)
je 0x4fcd9
leaq 0x7c4a6(%rip), %rsi     # 0xcc159
leaq 0x895b5(%rip), %rdx     # 0xd926f
leaq 0x89533(%rip), %rcx     # 0xd91f4
leaq 0x8949c(%rip), %r8      # 0xd9164
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x80, %r9d
jmp 0x4fc31
movb $0x1, %r15b
jmp 0x4fc38
movq 0xde2d0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a374(%rip), %rsi     # 0xca066
leaq 0x7a960(%rip), %rdx     # 0xca659
leaq 0x894f4(%rip), %rcx     # 0xd91f4
leaq 0x8945d(%rip), %r8      # 0xd9164
pushq $0x79
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x4fd83
movq %rdi, %rbx
pushq $0x1
popq %r12
xorl %r14d, %r14d
decq %r12
cmpq $0x0, (%rbx,%r14)
leaq 0x8(%r14), %r14
jne 0x4fd30
leaq 0x89565(%rip), %rsi     # 0xd92aa
pushq $0x1e
popq %rdx
movq %r14, %rdi
callq 0xccb0
movq %rax, %r15
negq %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x4fd70
movq (%rbx,%r13,8), %rdi
callq 0x4f8ae
movq %rax, (%r15,%r13,8)
incq %r13
jmp 0x4fd59
andq $0x0, -0x8(%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xde22e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a2d2(%rip), %rsi     # 0xca066
leaq 0x894f2(%rip), %rdx     # 0xd928d
leaq 0x894f6(%rip), %rcx     # 0xd9298
leaq 0x89501(%rip), %r8      # 0xd92aa
pushq $0x1c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4fe78
movq %rsi, %r12
testq %rsi, %rsi
je 0x4fe78
movq %rdi, %rbx
callq 0x4feae
movq %rax, %r14
leaq 0x8(,%rax,8), %rdi
leaq 0x894b7(%rip), %r13     # 0xd92aa
pushq $0x2b
popq %rdx
movq %r13, %rsi
callq 0xccb0
movq %rax, %r15
movq %r12, %rdi
callq 0xb260
movq %rax, %rbp
movq (%rbx), %rdi
callq 0xb260
addq %rax, %rbp
addq $0x2, %rbp
pushq $0x2d
popq %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0xccb0
movq %rax, (%r15)
movq (%rbx), %r8
leaq 0x7b353(%rip), %rdx     # 0xcb189
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xba00
pushq $0x1
popq %r12
cmpq %r14, %r12
jae 0x4fe61
movq (%rbx,%r12,8), %rdi
callq 0x4f8ae
movq %rax, (%r15,%r12,8)
incq %r12
jmp 0x4fe4a
andq $0x0, (%r15,%r14,8)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xde139(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a1dd(%rip), %rsi     # 0xca066
leaq 0x89430(%rip), %rdx     # 0xd92c0
leaq 0x89439(%rip), %rcx     # 0xd92d0
leaq 0x8940c(%rip), %r8      # 0xd92aa
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4ff33
movq %rsi, %r12
testq %rsi, %rsi
je 0x4ff33
movq %rdi, %rbx
callq 0x4feae
movq %rax, %r14
leaq 0x10(,%rax,8), %rdi
leaq 0x893bd(%rip), %rsi     # 0xd92aa
pushq $0x3b
popq %rdx
callq 0xccb0
movq %rax, %r15
movq %r12, %rdi
callq 0x4f8ae
movq %rax, (%r15)
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x4ff1e
movq (%rbx,%r12,8), %rdi
callq 0x4f8ae
movq %rax, 0x8(%r15,%r12,8)
incq %r12
jmp 0x4ff06
andq $0x0, 0x8(%r15,%r14,8)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xde07e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7a122(%rip), %rsi     # 0xca066
leaq 0x89375(%rip), %rdx     # 0xd92c0
leaq 0x89399(%rip), %rcx     # 0xd92eb
leaq 0x89351(%rip), %r8      # 0xd92aa
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x20
popq %rbp
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0x4ffa5
testq %r15, %r15
je 0x4ff98
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1640e
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1642f
incq %r15
jmp 0x4ff7c
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1640e
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x20
popq %rbp
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0x4fff6
testq %r15, %r15
je 0x4ffe9
movl %ebp, %edi
movq %rbx, %rsi
callq 0x54619
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x54691
incq %r15
jmp 0x4ffcd
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x54619
// File: /workspace/github_c_makefile_star2_O2/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 0x5005b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x89289(%rip), %r14     # 0xd92aa
pushq $0x68
popq %rbp
movq %rdi, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x5003f
movq %r14, %rsi
movl %ebp, %edx
callq 0xd249
addq $0x8, %r15
jmp 0x50027
leaq 0x89264(%rip), %rsi     # 0xd92aa
pushq $0x69
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x50100
movq %rsi, %r14
testq %rsi, %rsi
je 0x50100
movq %rdi, %rbx
movq %r14, %rsi
callq 0x5018a
testq %rax, %rax
jne 0x5012a
movq %r14, %rdi
callq 0x4f8ae
movq %rsp, %rsi
movq %rax, (%rsi)
movq (%rbx), %rdi
callq 0x56680
cmpl $0x1, %eax
jne 0x50154
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xddeb1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79f55(%rip), %rsi     # 0xca066
leaq 0x89200(%rip), %rdx     # 0xd9318
leaq 0x89207(%rip), %rcx     # 0xd9326
leaq 0x891dc(%rip), %r8      # 0xd9302
pushq $0x30
jmp 0x5017c
movq 0xdde87(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79f2b(%rip), %rsi     # 0xca066
leaq 0x891f6(%rip), %rdx     # 0xd9338
leaq 0x891dd(%rip), %rcx     # 0xd9326
leaq 0x891b2(%rip), %r8      # 0xd9302
pushq $0x31
jmp 0x5017c
movq 0xdde5d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79f01(%rip), %rsi     # 0xca066
leaq 0x80a06(%rip), %rdx     # 0xd0b72
leaq 0x891b3(%rip), %rcx     # 0xd9326
leaq 0x89188(%rip), %r8      # 0xd9302
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x501b2
testq %rsi, %rsi
je 0x501b2
movq (%rdi), %rdi
movq %rsp, %rsi
callq 0x565c1
testq %rax, %rax
je 0x501ae
movq (%rax), %rax
jmp 0x501b0
xorl %eax, %eax
popq %rcx
retq
movq 0xdddff(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79ea3(%rip), %rsi     # 0xca066
leaq 0x8914e(%rip), %rdx     # 0xd9318
leaq 0x89187(%rip), %rcx     # 0xd9358
leaq 0x8912a(%rip), %r8      # 0xd9302
pushq $0x3a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x50227
movq %rdi, %r14
callq 0x1532c
movq %rax, %rbx
movq (%r14), %rdi
leaq 0x81(%rip), %rsi        # 0x50287
leaq 0x11a0c(%rip), %rcx     # 0x61c19
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x56bfb
testl %eax, %eax
jne 0x50251
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xddd8a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79e2e(%rip), %rsi     # 0xca066
leaq 0x877eb(%rip), %rdx     # 0xd7a2a
leaq 0x89124(%rip), %rcx     # 0xd936a
leaq 0x890b5(%rip), %r8      # 0xd9302
pushq $0x4d
jmp 0x50279
movq 0xddd60(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79e04(%rip), %rsi     # 0xca066
leaq 0x7a3aa(%rip), %rdx     # 0xca613
leaq 0x890fa(%rip), %rcx     # 0xd936a
leaq 0x8908b(%rip), %r8      # 0xd9302
pushq $0x51
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x502a2
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x502eb
testq %r14, %r14
je 0x502c1
testq %rbx, %rbx
je 0x502c1
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x15407
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xddcf0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79d94(%rip), %rsi     # 0xca066
leaq 0x8918d(%rip), %rdx     # 0xd9466
leaq 0x8917b(%rip), %rcx     # 0xd945b
leaq 0x8901b(%rip), %r8      # 0xd9302
pushq $0x44
jmp 0x50313
movq 0xddcc6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79d6a(%rip), %rsi     # 0xca066
leaq 0x7a356(%rip), %rdx     # 0xca659
leaq 0x89151(%rip), %rcx     # 0xd945b
leaq 0x88ff1(%rip), %r8      # 0xd9302
pushq $0x43
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/cstr_table.c
// Function: gt_cstr_table_unit_test
int gt_cstr_table_unit_test(GtError *err)
{
  GtCstrTable *table;
  GtStrArray *sta;
  int had_err = 0;
  gt_error_check(err);
  table = gt_cstr_table_new();
  gt_ensure(!gt_cstr_table_get(table, "foo"));
  if (!had_err)
    gt_cstr_table_add(table, "foo");
  gt_ensure(!strcmp(gt_cstr_table_get(table, "foo"), "foo"));
  sta = gt_cstr_table_get_all(table);
  gt_ensure(gt_str_array_size(sta) == 1);
  gt_ensure(strcmp(gt_str_array_get(sta, 0), "foo") == 0);
  gt_str_array_delete(sta);
  gt_cstr_table_delete(table);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x503d7
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x50525
callq 0x5005c
movq %rax, %rbx
leaq 0x8ab1b(%rip), %rsi     # 0xdaf01
movq %rax, %rdi
callq 0x5018a
testq %rax, %rax
je 0x50416
leaq 0x7bd5f(%rip), %rsi     # 0xcc159
leaq 0x88fc0(%rip), %rdx     # 0xd93c1
leaq 0x88fa1(%rip), %rcx     # 0xd93a9
leaq 0x88ef3(%rip), %r8      # 0xd9302
xorl %r12d, %r12d
pushq $0x68
jmp 0x50467
leaq 0x8aae4(%rip), %r15     # 0xdaf01
movq %rbx, %rdi
movq %r15, %rsi
callq 0x500bc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5018a
movq %rax, %rdi
movq %r15, %rsi
callq 0xb880
testl %eax, %eax
je 0x5051d
leaq 0x7bd0c(%rip), %rsi     # 0xcc159
leaq 0x88f8e(%rip), %rdx     # 0xd93e2
leaq 0x88f4e(%rip), %rcx     # 0xd93a9
leaq 0x88ea0(%rip), %r8      # 0xd9302
xorl %r12d, %r12d
pushq $0x6b
popq %r9
movq %r14, %rdi
xorl %eax, %eax
callq 0xc007
movq %rbx, %rdi
callq 0x501e8
movq %rax, %r15
pushq $-0x1
popq %rbp
testb %r12b, %r12b
je 0x504fe
movq %r15, %rdi
callq 0x157f4
cmpq $0x1, %rax
jne 0x504d4
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
callq 0x1555e
leaq 0x8aa59(%rip), %rsi     # 0xdaf01
movq %rax, %rdi
callq 0xb880
testl %eax, %eax
je 0x50501
leaq 0x7bc9e(%rip), %rsi     # 0xcc159
leaq 0x88f6c(%rip), %rdx     # 0xd942e
leaq 0x88ee0(%rip), %rcx     # 0xd93a9
leaq 0x88e32(%rip), %r8      # 0xd9302
pushq $0x6e
jmp 0x504f2
leaq 0x7bc7e(%rip), %rsi     # 0xcc159
leaq 0x88f30(%rip), %rdx     # 0xd9412
leaq 0x88ec0(%rip), %rcx     # 0xd93a9
leaq 0x88e12(%rip), %r8      # 0xd9302
pushq $0x6d
popq %r9
movq %r14, %rdi
xorl %eax, %eax
callq 0xc007
movl %ebp, %r12d
movq %r15, %rdi
callq 0x1583a
movq %rbx, %rdi
callq 0x5055b
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r12b
jmp 0x50473
movq 0xdda8c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79b30(%rip), %rsi     # 0xca066
leaq 0x7a11c(%rip), %rdx     # 0xca659
leaq 0x88e65(%rip), %rcx     # 0xd93a9
leaq 0x88db7(%rip), %r8      # 0xd9302
pushq $0x66
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x88ee9(%rip), %rdx     # 0xd9474
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
pushq $0x31
popq %rcx
callq 0xce9a
testq %rbx, %rbx
leaq 0xd(%rip), %rcx         # 0x505b0
cmoveq %rbx, %rcx
movq %rcx, (%rax)
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x88eb1(%rip), %rdx     # 0xd9474
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
pushq $0x3c
popq %rcx
callq 0xce9a
movq %r14, (%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x506b1
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x506a2
movq 0x10(%r15), %r12
movq (%r14), %rax
testq %rax, %rax
je 0x5069d
movq 0x18(%r14), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq *%rax
testl %eax, %eax
je 0x506a2
cmpq %rbx, %r12
jne 0x50678
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xdd900(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x799a4(%rip), %rsi     # 0xca066
leaq 0x88dbc(%rip), %rdx     # 0xd9485
leaq 0x88dd8(%rip), %rcx     # 0xd94a8
leaq 0x88d9d(%rip), %r8      # 0xd9474
pushq $0x52
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x50ad4
testq %rsi, %rsi
je 0x50ad4
movq (%rsi), %rax
testq %rax, %rax
je 0x50a7a
cmpq %rsi, 0x8(%rax)
jne 0x50b02
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x50a8c
cmpq %rsi, (%rcx)
jne 0x50b30
testq %rax, %rax
je 0x50a99
movq %rcx, 0x8(%rax)
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x50aa1
movq %rax, (%rcx)
cmpq %rsi, 0x8(%rdi)
jne 0x50aab
movq %rcx, 0x8(%rdi)
cmpq %rsi, 0x10(%rdi)
jne 0x50ab8
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
decq 0x20(%rdi)
leaq 0x889b1(%rip), %rax     # 0xd9474
movq %rsi, %rdi
movq %rax, %rsi
movl $0xad, %edx
popq %rax
jmp 0xd249
movq 0xdd4dd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79581(%rip), %rsi     # 0xca066
leaq 0x88a41(%rip), %rdx     # 0xd952d
leaq 0x88a4d(%rip), %rcx     # 0xd9540
leaq 0x8897a(%rip), %r8      # 0xd9474
movl $0xa1, %r9d
jmp 0x50b5c
movq 0xdd4af(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79553(%rip), %rsi     # 0xca066
leaq 0x88a36(%rip), %rdx     # 0xd9550
leaq 0x88a1f(%rip), %rcx     # 0xd9540
leaq 0x8894c(%rip), %r8      # 0xd9474
movl $0xa2, %r9d
jmp 0x50b5c
movq 0xdd481(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79525(%rip), %rsi     # 0xca066
leaq 0x88a47(%rip), %rdx     # 0xd958f
leaq 0x889f1(%rip), %rcx     # 0xd9540
leaq 0x8891e(%rip), %r8      # 0xd9474
movl $0xa3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x50b82
callq 0xc103
testb %al, %al
jne 0x50bcc
xorl %edi, %edi
callq 0x50580
movq %rax, %rbx
leaq 0x4(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x5077a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5077a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5077a
movq %rbx, %rdi
callq 0x505e0
movq %rbx, %rdi
callq 0x50c04
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xdd3e5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x79489(%rip), %rsi     # 0xca066
leaq 0x79a75(%rip), %rdx     # 0xca659
leaq 0x889df(%rip), %rcx     # 0xd95ca
leaq 0x88882(%rip), %r8      # 0xd9474
movl $0xbb, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x50c63
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8885c(%rip), %r14     # 0xd9474
movq %rdi, %r15
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x50c36
movq (%r15), %rdi
movq %r14, %rsi
movl $0x173, %edx            # imm = 0x173
callq 0xd249
jmp 0x50c1b
movq 0x10(%rbx), %rdi
leaq 0x88833(%rip), %r14     # 0xd9474
movq %r14, %rsi
movl $0x176, %edx            # imm = 0x176
callq 0xd249
movq %rbx, %rdi
movq %r14, %rsi
movl $0x177, %edx            # imm = 0x177
popq %rbx
popq %r14
popq %r15
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x51702
movq %rdx, %r14
testq %rdx, %rdx
je 0x51702
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %r14, %rax
jae 0x516d6
testq %rax, %rax
je 0x516e0
pushq $-0x1
popq %rcx
cmpq %r14, %rax
jae 0x516db
testq %rax, %rax
leaq (%rax,%rax), %rax
cmovsq %rcx, %rax
jmp 0x516c4
movq %rdi, %rax
jmp 0x516fa
movq %rax, %r14
jmp 0x516e5
testq %rdi, %rdi
jne 0x51738
leaq 0x8811a(%rip), %rdx     # 0xd9806
pushq $0x2c
popq %rcx
movq %r14, %rsi
callq 0xcfc2
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xdc8af(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x78953(%rip), %rsi     # 0xca066
leaq 0x880ce(%rip), %rdx     # 0xd97e8
leaq 0x880d9(%rip), %rcx     # 0xd97fa
leaq 0x880de(%rip), %r8      # 0xd9806
pushq $0x19
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0xdc879(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7891d(%rip), %rsi     # 0xca066
leaq 0x880ca(%rip), %rdx     # 0xd981a
leaq 0x880a3(%rip), %rcx     # 0xd97fa
leaq 0x880a8(%rip), %r8      # 0xd9806
pushq $0x1d
jmp 0x5172a
nop
// File: /workspace/github_c_makefile_star2_O2/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, 0xde453(%rip)     # 0x12fbc0
jne 0x517e6
leaq 0x880bf(%rip), %rdx     # 0xd9835
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
pushq $0x59
popq %rcx
callq 0xce9a
movq %rax, 0xde435(%rip)     # 0x12fbc0
callq 0x15f7b
movq 0xde429(%rip), %rcx     # 0x12fbc0
movq %rax, (%rcx)
callq 0x15f7b
movq 0xde41a(%rip), %rcx     # 0x12fbc0
movq %rax, 0x8(%rcx)
leaq 0x6b(%rip), %rdx        # 0x5181c
xorl %edi, %edi
xorl %esi, %esi
callq 0x55da4
movq 0xde3ff(%rip), %rcx     # 0x12fbc0
movq %rax, 0x10(%rcx)
leaq 0x5f(%rip), %rdx        # 0x5182b
xorl %edi, %edi
xorl %esi, %esi
callq 0x55da4
movq 0xde3e4(%rip), %rcx     # 0x12fbc0
movq %rax, 0x18(%rcx)
movb $0x0, 0x30(%rcx)
popq %rax
retq
movq 0xdc7cb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7886f(%rip), %rsi     # 0xca066
leaq 0x88028(%rip), %rdx     # 0xd9826
leaq 0x88025(%rip), %rcx     # 0xd982a
leaq 0x88029(%rip), %r8      # 0xd9835
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300