LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ltablib.c
// Function: sort_comp
static int sort_comp (lua_State *L, int a, int b) {
  if (!lua_isnil(L, 2)) {  /* function? */
    int res;
    lua_pushvalue(L, 2);
    lua_pushvalue(L, a-1);  /* -1 to compensate function */
    lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
    lua_call(L, 2, 1);
    res = lua_toboolean(L, -1);
    lua_pop(L, 1);
    return res;
  }
  else  /* a < b? */
    return lua_lessthan(L, a, b);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
addq $0x10, %rcx
cmpq %rax, %rcx
leaq 0x7ee90(%rip), %rdx     # 0xed710
cmovaeq %rdx, %rcx
cmpq %rdx, %rcx
je 0x6e893
cmpl $0x0, 0x8(%rcx)
je 0x6e92c
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x10, 0x10(%rbx)
decl %esi
movq %rbx, %rdi
callq 0x57945
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
addl $-0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x57945
movq 0x10(%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x20, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x594c2
movq 0x10(%rbx), %rcx
movl -0x8(%rcx), %eax
testl %eax, %eax
je 0x6e91d
cmpl $0x1, %eax
jne 0x6e918
xorl %eax, %eax
cmpl $0x0, -0x10(%rcx)
setne %al
jmp 0x6e91d
movl $0x1, %eax
addq $-0x10, %rcx
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x57f08
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_new
GtArray* gt_array_new(size_t size_of_elem)
{
  GtArray *a = gt_calloc(1, sizeof *a);
  gt_assert(size_of_elem);
  a->size_of_elem = size_of_elem;
  return a;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x8067f(%rip), %rdx     # 0xeefc6
movl $0x1, %edi
movl $0x28, %esi
movl $0x2b, %ecx
callq 0x3601f
testq %rbx, %rbx
je 0x6e966
movq %rbx, 0x18(%rax)
popq %rbx
retq
callq 0x18e26
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_clone
GtArray* gt_array_clone(const GtArray *a)
{
  GtArray *a_copy;
  gt_assert(a);
  a_copy = gt_malloc(sizeof (GtArray));
  a_copy->space = gt_malloc(a->next_free * a->size_of_elem);
  memcpy(a_copy->space, a->space, a->next_free * a->size_of_elem);
  a_copy->next_free = a_copy->allocated = a->next_free;
  a_copy->size_of_elem = a->size_of_elem;
  a_copy->reference_count = 0;
  return a_copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6e9e6
movq %rdi, %rbx
leaq 0x80647(%rip), %r14     # 0xeefc6
movl $0x28, %edi
movq %r14, %rsi
movl $0x35, %edx
callq 0x35ee2
movq %rax, %r15
movq 0x18(%rbx), %rdi
imulq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x36, %edx
callq 0x35ee2
movq %rax, (%r15)
movq (%rbx), %rsi
movq 0x18(%rbx), %rdx
imulq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0xb520
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r15)
movq %rax, 0x8(%r15)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r15)
movl $0x0, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x18e5d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_rem
void gt_array_rem(GtArray *a, GtUword idx)
{
  GtUword i;
  gt_assert(a && idx < a->next_free);
  /* move elements */
  for (i = idx + 1; i < a->next_free; i++) {
    memcpy((char*) a->space + (i-1) * a->size_of_elem,
           (char*) a->space + i * a->size_of_elem,
           a->size_of_elem);
  }
  /* remove last (now duplicated) element */
  a->next_free--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6eabd
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, 0x8(%rdi)
jbe 0x6eabd
leaq 0x1(%r14), %rcx
movq 0x8(%rbx), %rax
cmpq %rax, %rcx
jae 0x6eab0
leaq 0x1(%r14), %r15
movq (%rbx), %rax
movq 0x18(%rbx), %rdx
movq %rdx, %rdi
imulq %r14, %rdi
addq %rax, %rdi
movq %rdx, %rsi
imulq %r15, %rsi
addq %rax, %rsi
callq 0xb520
movq 0x8(%rbx), %rax
addq $0x2, %r14
cmpq %rax, %r14
movq %r15, %r14
jb 0x6ea7c
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x18f39
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_rem_span
void gt_array_rem_span(GtArray *a, GtUword frompos, GtUword topos)
{
  GtUword i, len;
  gt_assert(a && frompos <= topos);
  gt_assert(frompos < a->next_free && topos < a->next_free);
  /* move elements */
  len = topos - frompos + 1;
  for (i = topos + 1; i < a->next_free; i++) {
    memcpy((char*) a->space + (i-len) * a->size_of_elem,
           (char*) a->space + i * a->size_of_elem,
           a->size_of_elem);
  }
  /* remove last (now duplicated) elements */
  a->next_free -= len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6eb3c
movq %rdx, %r14
movq %rsi, %r15
movq %rdx, %r12
subq %rsi, %r12
jb 0x6eb3c
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %r15, %rax
jbe 0x6eb41
cmpq %r14, %rax
jbe 0x6eb41
incq %r14
movq 0x8(%rbx), %rax
cmpq %rax, %r14
jae 0x6eb26
movq (%rbx), %rax
movq 0x18(%rbx), %rdx
movq %rdx, %rdi
imulq %r15, %rdi
addq %rax, %rdi
movq %rdx, %rsi
imulq %r14, %rsi
addq %rax, %rsi
callq 0xb520
incq %r14
movq 0x8(%rbx), %rax
incq %r15
jmp 0x6eaf5
notq %r12
addq %rax, %r12
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x18fa7
callq 0x18f70
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_reverse
void gt_array_reverse(GtArray *a)
{
  char *front, *back, *tmp;
  gt_assert(a);
  tmp = gt_malloc(a->size_of_elem);
  for (front = a->space,
       back = (char*) a->space + (a->next_free-1) * a->size_of_elem;
       front < back; front += a->size_of_elem, back -= a->size_of_elem) {
    memcpy(tmp, front, a->size_of_elem);
    memcpy(front, back, a->size_of_elem);
    memcpy(back, tmp, a->size_of_elem);
  }
  gt_free(tmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6ebe4
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x80461(%rip), %rsi     # 0xeefc6
movl $0x7f, %edx
callq 0x35ee2
movq %rax, %r14
movq 0x8(%rbx), %r15
decq %r15
imulq 0x18(%rbx), %r15
testq %r15, %r15
jle 0x6ebc5
movq (%rbx), %r12
addq %r12, %r15
movq 0x18(%rbx), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xb520
movq 0x18(%rbx), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xb520
movq 0x18(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb520
movq 0x18(%rbx), %rax
addq %rax, %r12
subq %rax, %r15
cmpq %r15, %r12
jb 0x6eb89
leaq 0x803fa(%rip), %rsi     # 0xeefc6
movq %r14, %rdi
movl $0x87, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x362a0
callq 0x18fde
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_add_elem
void gt_array_add_elem(GtArray *a, void *elem, size_t size_of_elem)
{
  gt_assert(a && elem);
  gt_assert(a->size_of_elem == size_of_elem);
  gt_assert(a->next_free <= a->allocated);
  /* make sure we have enough space */
  if ((a->next_free + 1) * size_of_elem > a->allocated) {
    a->space = gt_dynalloc(a->space, &a->allocated,
                           (a->next_free + 1) * size_of_elem);
  }
  /* add */
  memcpy((char*) a->space + a->next_free * size_of_elem, elem, size_of_elem);
  a->next_free++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6ec74
movq %rsi, %r15
testq %rsi, %rsi
je 0x6ec74
movq %rdx, %r14
movq %rdi, %rbx
cmpq %rdx, 0x18(%rdi)
jne 0x6ec79
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rax
cmpq %rax, %rdx
ja 0x6ec7e
incq %rdx
imulq %r14, %rdx
cmpq %rax, %rdx
jbe 0x6ec54
leaq 0x10(%rbx), %rsi
movq (%rbx), %rdi
callq 0x73b98
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
imulq %r14, %rdi
addq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb520
incq 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x1904e
callq 0x19087
callq 0x190c0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_add_array
void gt_array_add_array(GtArray *dest, const GtArray *src)
{
  GtUword i;
  gt_assert(dest && src && dest->size_of_elem == src->size_of_elem);
  for (i = 0; i < gt_array_size(src); i++)
    gt_array_add_elem(dest, gt_array_get(src, i), src->size_of_elem);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6ecd5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x6ecd5
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq 0x18(%rbx), %rax
jne 0x6ecd5
cmpq $0x0, 0x8(%rbx)
je 0x6eccf
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq 0x18(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x6ec0e
incq %r15
cmpq 0x8(%rbx), %r15
jb 0x6ecac
popq %rbx
popq %r14
popq %r15
retq
callq 0x190f9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_cmp
int gt_array_cmp(const GtArray *array_a, const GtArray *array_b)
{
  gt_assert(gt_array_size(array_a) == gt_array_size(array_b));
  gt_assert(gt_array_elem_size(array_a) == gt_array_elem_size(array_b));
  return memcmp(array_a->space, array_b->space,
                array_a->size_of_elem * array_a->next_free);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x6eddb
movq 0x8(%rbx), %rax
jmp 0x6eddd
xorl %eax, %eax
testq %r14, %r14
je 0x6ede8
movq 0x8(%r14), %rcx
jmp 0x6edea
xorl %ecx, %ecx
cmpq %rcx, %rax
jne 0x6ee20
movq %rbx, %rdi
callq 0x6ece7
movq %rax, %r15
movq %r14, %rdi
callq 0x6ece7
cmpq %rax, %r15
jne 0x6ee25
movq (%r14), %rsi
movq 0x8(%rbx), %rdx
imulq 0x18(%rbx), %rdx
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb270
callq 0x192fa
callq 0x19333
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_equal
bool gt_array_equal(const GtArray *a, const GtArray *b, GtCompare cmpfunc)
{
  GtUword idx, size_a, size_b;
  int cmp;
  gt_assert(gt_array_elem_size(a) == gt_array_elem_size(b));
  size_a = gt_array_size(a);
  size_b = gt_array_size(b);
  if (size_a < size_b)
    return false;
  if (size_a > size_b)
    return false;
  for (idx = 0; idx < size_a; idx++) {
    cmp = cmpfunc(gt_array_get(a, idx), gt_array_get(b, idx));
    if (cmp != 0)
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x6ece7
movq %rax, %r12
movq %r14, %rdi
callq 0x6ece7
cmpq %rax, %r12
jne 0x6eec9
testq %r15, %r15
je 0x6ee5e
movq 0x8(%r15), %rbp
jmp 0x6ee60
xorl %ebp, %ebp
testq %r14, %r14
je 0x6ee6b
movq 0x8(%r14), %rax
jmp 0x6ee6d
xorl %eax, %eax
cmpq %rax, %rbp
jne 0x6eeb4
testq %rbp, %rbp
je 0x6eeb8
decq %rbp
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x6e9fa
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x6e9fa
movq %r13, %rdi
movq %rax, %rsi
callq *%rbx
testl %eax, %eax
sete %al
jne 0x6eeba
leaq 0x1(%r12), %rcx
cmpq %r12, %rbp
movq %rcx, %r12
jne 0x6ee7d
jmp 0x6eeba
xorl %eax, %eax
jmp 0x6eeba
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1936c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_iterate
int gt_array_iterate(GtArray *a, GtArrayProcessor array_processor, void *info,
                  GtError *err)
{
  GtUword idx;
  int rval;
  gt_error_check(err);
  gt_assert(a && array_processor);
  for (idx = 0; idx < gt_array_size(a); idx++) {
    if ((rval = array_processor(gt_array_get(a, idx), info, err)))
      return rval;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x6eef4
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x6ef3f
testq %r12, %r12
je 0x6ef3a
testq %r15, %r15
je 0x6ef3a
cmpq $0x0, 0x8(%r12)
je 0x6ef2e
xorl %r13d, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x6e9fa
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
testl %eax, %eax
jne 0x6ef30
incq %r13
cmpq 0x8(%r12), %r13
jb 0x6ef09
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x193de
callq 0x193a5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_iterate_reverse
int gt_array_iterate_reverse(GtArray *a, GtArrayProcessor array_processor,
                             void *info, GtError *err)
{
  GtUword idx;
  int rval;
  gt_error_check(err);
  gt_assert(a && array_processor);
  for (idx = gt_array_size(a); idx > 0; idx--) {
    if ((rval = array_processor(gt_array_get(a, idx-1), info, err)))
      return rval;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x6ef6a
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x6efb3
testq %r12, %r12
je 0x6efae
testq %r15, %r15
je 0x6efae
movq 0x8(%r12), %r13
decq %r13
cmpq $-0x1, %r13
je 0x6efa2
movq %r12, %rdi
movq %r13, %rsi
callq 0x6e9fa
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
decq %r13
testl %eax, %eax
je 0x6ef7c
jmp 0x6efa4
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x19450
callq 0x19417
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_prepend_array
void gt_array_prepend_array(GtArray *dest, const GtArray *src)
{
  GtUword i;
  gt_assert(dest && src && dest->size_of_elem == src->size_of_elem);
  if (!src->next_free)
    return; /* nothing to do */
  /* make sure <dest> is large enough */
  dest->space = gt_dynalloc(dest->space, &dest->allocated,
                            (dest->next_free + src->next_free) *
                            dest->size_of_elem);
  /* move elements in <dest> to the back */
  for (i = dest->next_free; i > 0; i--) {
    memcpy((char*) dest->space + (i-1+src->next_free) * dest->size_of_elem,
           (char*) dest->space + (i-1) * dest->size_of_elem,
           dest->size_of_elem);
  }
  /* copy <src> to the start of <dest> */
  memcpy((char*) dest->space, (char*) src->space,
         src->size_of_elem * src->next_free);
  dest->next_free += src->next_free;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6f057
movq %rsi, %r14
testq %rsi, %rsi
je 0x6f057
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x18(%r14), %rax
jne 0x6f057
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x6f051
movq (%rbx), %rdi
leaq 0x10(%rbx), %rsi
addq 0x8(%rbx), %rdx
imulq %rax, %rdx
callq 0x73b98
movq %rax, (%rbx)
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x6f035
decq %r15
movq 0x8(%r14), %rdi
addq %r15, %rdi
movq (%rbx), %rax
movq 0x18(%rbx), %rdx
imulq %rdx, %rdi
addq %rax, %rdi
movq %rdx, %rsi
imulq %r15, %rsi
addq %rax, %rsi
callq 0xb520
addq $-0x1, %r15
jb 0x6f00b
movq (%rbx), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
imulq 0x18(%r14), %rdx
callq 0xb520
movq 0x8(%r14), %rax
addq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x19489
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_example
int gt_array_example(GT_UNUSED GtError *err)
{
  GtUword i;
  GtArray *a;

  gt_error_check(err);

  /* an example array use case */

  a = gt_array_new(sizeof (GtUword));
  for (i = 0; i < 100; i++) {
    gt_array_add(a, i);
    gt_assert(i == *(GtUword*) gt_array_get(a, i));
  }
  gt_assert(gt_array_size(a) == 100);
  gt_assert(*(GtUword*) gt_array_pop(a) == 99);
  gt_assert(gt_array_size(a) == 99);
  gt_array_delete(a);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x6f077
callq 0x3566a
testb %al, %al
jne 0x6f12f
leaq 0x7ff48(%rip), %rdx     # 0xeefc6
movl $0x1, %edi
movl $0x28, %esi
movl $0x2b, %ecx
callq 0x3601f
movq %rax, %rbx
movq $0x8, 0x18(%rax)
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6ec0e
movq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6e9fa
cmpq (%rax), %r15
jne 0x6f11b
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
cmpq $0x64, %rax
jb 0x6f0a9
testq %rbx, %rbx
je 0x6f120
cmpq $0x64, 0x8(%rbx)
jne 0x6f120
movq %rbx, %rdi
callq 0x6ea35
cmpq $0x63, (%rax)
jne 0x6f12a
testq %rbx, %rbx
je 0x6f125
cmpq $0x63, 0x8(%rbx)
jne 0x6f125
movq %rbx, %rdi
callq 0x6f134
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x194fb
callq 0x195a6
callq 0x1956d
callq 0x19534
callq 0x194c2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: gt_array_delete
void gt_array_delete(GtArray *a)
{
  if (!a) return;
  if (a->reference_count) {
    a->reference_count--;
    return;
  }
  gt_free(a->space);
  gt_free(a);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6f14c
movq %rdi, %rbx
movl 0x20(%rdi), %eax
testl %eax, %eax
je 0x6f154
decl %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
leaq 0x7fe68(%rip), %r14     # 0xeefc6
movq %r14, %rsi
movl $0x204, %edx            # imm = 0x204
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x205, %edx            # imm = 0x205
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/array.c
// Function: iterate_test_func
static int iterate_test_func(void *value, void *info, GT_UNUSED GtError *err)
{
  GtUword *i;
  GtRange range;
  int had_err = 0;
  gt_error_check(err);
  i = (GtUword*) info;
  range = *(GtRange*) value;
  gt_ensure(range.start == *i + 1);
  gt_ensure(range.end == *i + 101);
  (*i)++;
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x7012d
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x701a6
movq (%rbx), %rcx
leaq 0x1(%rcx), %rax
cmpq %rax, (%r15)
jne 0x7016c
addq $0x65, %rcx
xorl %eax, %eax
cmpq %rcx, 0x8(%r15)
je 0x7019d
leaq 0x7302d(%rip), %rsi     # 0xe3179
leaq 0x7f67b(%rip), %rdx     # 0xef7ce
leaq 0x7f64c(%rip), %rcx     # 0xef7a6
leaq 0x7ee65(%rip), %r8      # 0xeefc6
movq %r14, %rdi
movl $0x133, %r9d            # imm = 0x133
jmp 0x70191
leaq 0x73006(%rip), %rsi     # 0xe3179
leaq 0x7f63e(%rip), %rdx     # 0xef7b8
leaq 0x7f625(%rip), %rcx     # 0xef7a6
leaq 0x7ee3e(%rip), %r8      # 0xeefc6
movq %r14, %rdi
movl $0x132, %r9d            # imm = 0x132
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incq (%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x19618
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/basename.c
// Function: gt_basename
char *gt_basename(const char *path)
{
  char *sbuf, *c;
  bool foundother = false;
  size_t i, pathlen;

  if (path != NULL)
    pathlen = strlen(path);
  else
    pathlen = 0;
  sbuf = gt_malloc(sizeof (char) * (pathlen + 2));
  if (path == NULL || *path == '\0') {
    strcpy(sbuf, ".");
    return sbuf;
  }
  strcpy(sbuf, path);
  for (c = sbuf + pathlen - 1; c >= sbuf; c--) {
    if (*c == GT_PATH_SEPARATOR) {
      if (foundother) {
        c++;
        for (i=0; c[i] != '\0'; i++)
          sbuf[i] = c[i];
        sbuf[i] = '\0';
        break;
      }
      if (c > sbuf)
        *c = '\0';
    }
    else
      foundother = true;
  }
  return sbuf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x701ce
movq %r14, %rdi
callq 0xb260
movq %rax, %r15
jmp 0x701d1
xorl %r15d, %r15d
leaq 0x2(%r15), %rdi
leaq 0x7f608(%rip), %rsi     # 0xef7e4
movl $0x23, %edx
callq 0x35ee2
movq %rax, %rbx
testq %r14, %r14
je 0x7022f
cmpb $0x0, (%r14)
je 0x7022f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb600
leaq (%rbx,%r15), %rax
decq %rax
cmpq %rbx, %rax
jb 0x70234
xorl %ecx, %ecx
movb $0x1, %dl
cmpb $0x2f, (%rax)
jne 0x70223
testb $0x1, %cl
jne 0x7023d
cmpq %rbx, %rax
jbe 0x70221
movb $0x0, (%rax)
movl %ecx, %edx
decq %rax
movl %edx, %ecx
cmpq %rbx, %rax
jae 0x7020d
jmp 0x70234
movw $0x2e, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movb 0x1(%rax), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x70259
movq %rbx, %rsi
movb %dl, (%rsi)
movb 0x2(%rax,%rcx), %dl
incq %rcx
incq %rsi
testb %dl, %dl
jne 0x70249
movb $0x0, (%rbx,%rcx)
jmp 0x70234
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_new
GtBittab* gt_bittab_new(GtUword num_of_bits)
{
  GtBittab *b;

  gt_assert(num_of_bits != 0);

  b = gt_malloc(sizeof (GtBittab));
  b->num_of_bits = num_of_bits;

  if (num_of_bits / (8UL * sizeof (GtUword)))
    b->tabsize = 1 + ((num_of_bits - 1) / (8UL * sizeof (GtUword)));
  else
    b->tabsize = 1UL;

  b->tabptr = gt_calloc(b->tabsize, sizeof (GtUword));

  return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7078b
movq %rdi, %rbx
leaq 0x7f185(%rip), %r14     # 0xef8bd
movl $0x18, %edi
movq %r14, %rsi
movl $0x2a, %edx
callq 0x35ee2
movq %rax, %r15
movq %rbx, 0x10(%rax)
leaq -0x1(%rbx), %rax
shrq $0x6, %rax
incq %rax
cmpq $0x40, %rbx
movl $0x1, %edi
cmovaeq %rax, %rdi
movq %rdi, 0x8(%r15)
movl $0x8, %esi
movq %r14, %rdx
movl $0x32, %ecx
callq 0x3601f
movq %rax, (%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x19688
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_complement
void gt_bittab_complement(GtBittab *dest, const GtBittab *src)
{
  GtUword i;

  gt_assert(dest && src && dest->num_of_bits == src->num_of_bits);

  for (i = 0; i < src->tabsize - 1; i++)
    dest->tabptr[i] = ~src->tabptr[i];

  /* the ``last'' bittab gets special treatment to prevent that unused bits
     become set. this could disturb subsequent gt_bittab_count_set_bits() calls.
   */
  dest->tabptr[src->tabsize - 1] = ~src->tabptr[src->tabsize - 1] &
                                   (~0UL >> (- src->num_of_bits +
                                             src->tabsize * 8UL *
                                             sizeof (GtUword)));
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70844
testq %rsi, %rsi
je 0x70844
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x70844
movq 0x8(%rsi), %rcx
movq %rcx, %rax
decq %rax
je 0x70825
movq (%rsi), %rdx
movq (%rdi), %r8
xorl %r9d, %r9d
movq (%rdx,%r9,8), %rax
notq %rax
movq %rax, (%r8,%r9,8)
incq %r9
movq 0x8(%rsi), %rcx
leaq -0x1(%rcx), %rax
cmpq %rax, %r9
jb 0x7080a
movq (%rsi), %rdx
movq (%rdx,%rax,8), %rdx
notq %rdx
shll $0x6, %ecx
subl 0x10(%rsi), %ecx
shlq %cl, %rdx
shrq %cl, %rdx
movq (%rdi), %rcx
movq %rdx, (%rcx,%rax,8)
popq %rax
retq
callq 0x1972d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_equal
void gt_bittab_equal(GtBittab *dest, const GtBittab *src)
{
  GtUword i;
  gt_assert(dest && src && dest->num_of_bits == src->num_of_bits);
  for (i = 0; i < src->tabsize; i++)
    dest->tabptr[i] = src->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70880
testq %rsi, %rsi
je 0x70880
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x70880
cmpq $0x0, 0x8(%rsi)
je 0x7087e
movq (%rsi), %rax
movq (%rdi), %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
cmpq 0x8(%rsi), %rdx
jb 0x7086d
popq %rax
retq
callq 0x19764
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_and
void gt_bittab_and(GtBittab *dest, const GtBittab *src1,
                   const GtBittab *src2)
{
  GtUword i;
  gt_assert(dest && src1 && src2);
  gt_assert(dest->num_of_bits == src1->num_of_bits);
  gt_assert(dest->num_of_bits == src2->num_of_bits);
  for (i = 0; i < src1->tabsize; i++)
    dest->tabptr[i] = src1->tabptr[i] & src2->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x708ce
testq %rsi, %rsi
je 0x708ce
testq %rdx, %rdx
je 0x708ce
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x708d3
cmpq 0x10(%rdx), %rax
jne 0x708d8
cmpq $0x0, 0x8(%rsi)
je 0x708cc
movq (%rsi), %rax
movq (%rdx), %rcx
movq (%rdi), %rdx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
andq (%rax,%rdi,8), %r8
movq %r8, (%rdx,%rdi,8)
incq %rdi
cmpq 0x8(%rsi), %rdi
jb 0x708b7
popq %rax
retq
callq 0x1979b
callq 0x197d2
callq 0x19809
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_or
void gt_bittab_or(GtBittab *dest, const GtBittab *src1, const GtBittab *src2)
{
  GtUword i;
  gt_assert(dest && src1 && src2);
  gt_assert(dest->num_of_bits == src1->num_of_bits);
  gt_assert(dest->num_of_bits == src2->num_of_bits);
  for (i = 0; i < src1->tabsize; i++)
    dest->tabptr[i] = src1->tabptr[i] | src2->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70926
testq %rsi, %rsi
je 0x70926
testq %rdx, %rdx
je 0x70926
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x7092b
cmpq 0x10(%rdx), %rax
jne 0x70930
cmpq $0x0, 0x8(%rsi)
je 0x70924
movq (%rsi), %rax
movq (%rdx), %rcx
movq (%rdi), %rdx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
orq (%rax,%rdi,8), %r8
movq %r8, (%rdx,%rdi,8)
incq %rdi
cmpq 0x8(%rsi), %rdi
jb 0x7090f
popq %rax
retq
callq 0x19840
callq 0x19877
callq 0x198ae
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_nand
void gt_bittab_nand(GtBittab *dest,
                  const GtBittab *minuend,
                  const GtBittab *subtrahend)
{
  GtUword i;
  gt_assert(dest && minuend && subtrahend);
  gt_assert(dest->num_of_bits == minuend->num_of_bits);
  gt_assert(minuend->num_of_bits == subtrahend->num_of_bits);
  for (i = 0; i < dest->tabsize; i++)
    dest->tabptr[i] = minuend->tabptr[i] & ~subtrahend->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70981
testq %rsi, %rsi
je 0x70981
testq %rdx, %rdx
je 0x70981
movq 0x10(%rsi), %rax
cmpq %rax, 0x10(%rdi)
jne 0x70986
cmpq 0x10(%rdx), %rax
jne 0x7098b
cmpq $0x0, 0x8(%rdi)
je 0x7097f
movq (%rsi), %rax
movq (%rdx), %rcx
movq (%rdi), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %r8
notq %r8
andq (%rax,%rsi,8), %r8
movq %r8, (%rdx,%rsi,8)
incq %rsi
cmpq 0x8(%rdi), %rsi
jb 0x70967
popq %rax
retq
callq 0x198e5
callq 0x1991c
callq 0x19953
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_and_equal
void gt_bittab_and_equal(GtBittab *dest, const GtBittab *src)
{
  GtUword i;
  gt_assert(dest && src);
  gt_assert(dest->num_of_bits == src->num_of_bits);
  for (i = 0; i < dest->tabsize; i++)
    dest->tabptr[i] &= src->tabptr[i];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x709c7
testq %rsi, %rsi
je 0x709c7
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x709cc
cmpq $0x0, 0x8(%rdi)
je 0x709c5
movq (%rsi), %rax
movq (%rdi), %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
andq %rsi, (%rcx,%rdx,8)
incq %rdx
cmpq 0x8(%rdi), %rdx
jb 0x709b4
popq %rax
retq
callq 0x1998a
callq 0x199c3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_shift_left_equal
void gt_bittab_shift_left_equal(GtBittab *b)
{
  GtUword i, new_carry, old_carry = 0;
  gt_assert(b);
  for (i = 0; i < b->tabsize; i++) {
    new_carry = b->tabptr[i] & ((GtUword) 1 << (8UL * sizeof (GtUword) - 1));
    b->tabptr[i] = (b->tabptr[i] << 1) | old_carry;
    old_carry = new_carry >> (8UL * sizeof (GtUword) - 1);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70a44
cmpq $0x0, 0x8(%rdi)
je 0x70a42
movq (%rdi), %rax
xorl %edx, %edx
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rsi
leaq (%rdx,%rsi,2), %rdx
movq %rdx, (%rax,%rcx,8)
shrq $0x3f, %rsi
incq %rcx
movq %rsi, %rdx
cmpq 0x8(%rdi), %rcx
jb 0x70a26
popq %rax
retq
callq 0x19a6e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_shift_right_equal
void gt_bittab_shift_right_equal(GtBittab *b)
{
  GtUword i, new_carry, old_carry = 0;
  gt_assert(b);
  for (i = b->tabsize; i > 0; i--) {
    new_carry = b->tabptr[i-1] & 1UL;
    b->tabptr[i-1] = (b->tabptr[i-1] >> 1) | old_carry;
    old_carry = new_carry << (8UL * sizeof (GtUword) - 1);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70a7e
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x70a7c
movq (%rdi), %rcx
xorl %edx, %edx
movq -0x8(%rcx,%rax,8), %rsi
movq %rsi, %rdi
shrq %rdi
orq %rdx, %rdi
movq %rdi, -0x8(%rcx,%rax,8)
shlq $0x3f, %rsi
movq %rsi, %rdx
decq %rax
jne 0x70a5d
popq %rax
retq
callq 0x19aa7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_unset
void gt_bittab_unset(GtBittab *b)
{
  GtUword i;
  gt_assert(b);
  for (i = 0; i < b->tabsize; i++)
    b->tabptr[i] = 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70aa8
cmpq $0x0, 0x8(%rdi)
je 0x70aa6
movq (%rdi), %rax
xorl %ecx, %ecx
movq $0x0, (%rax,%rcx,8)
incq %rcx
cmpq 0x8(%rdi), %rcx
jb 0x70a95
popq %rax
retq
callq 0x19ae0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_get_all_bitnums
void gt_bittab_get_all_bitnums(const GtBittab *b, GtArray *bitnums)
{
  GtUword i;
  gt_assert(b && bitnums);
  for (i = 0; i < b->num_of_bits; i++)
    if (gt_bittab_bit_is_set(b, i)) gt_array_add(bitnums, i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x70b16
movq %rsi, %rbx
testq %rsi, %rsi
je 0x70b16
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rdi)
je 0x70b0c
xorl %esi, %esi
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x70b1b
testb %al, %al
je 0x70af9
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ec0e
movq 0x8(%rsp), %rsi
incq %rsi
movq %rsi, 0x8(%rsp)
cmpq 0x10(%r14), %rsi
jb 0x70add
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x19b19
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_is_true
bool gt_bittab_is_true(const GtBittab *b)
{
  GtUword i;
  gt_assert(b);
  for (i = 0; i < b->tabsize; i++) {
    if (b->tabptr[i])
      return true;
  }
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70b7d
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
setne %al
je 0x70b7b
movq (%rdi), %rdx
cmpq $0x0, (%rdx)
jne 0x70b7b
movl $0x1, %esi
movq %rsi, %rax
cmpq %rsi, %rcx
je 0x70b75
leaq 0x1(%rax), %rsi
cmpq $0x0, (%rdx,%rax,8)
je 0x70b62
cmpq %rcx, %rax
setb %al
popq %rcx
retq
callq 0x19b8b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_cmp
bool gt_bittab_cmp(const GtBittab *b1, const GtBittab *b2)
{
  GtUword i;
  gt_assert(b1 && b2 && b1->num_of_bits == b2->num_of_bits);
  for (i = 0; i < b1->tabsize; i++) {
    if (b1->tabptr[i] != b2->tabptr[i])
      return false;
  }
  return true;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x70bd4
testq %rsi, %rsi
je 0x70bd4
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x70bd4
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
sete %al
je 0x70bd2
movq (%rdi), %rdx
movq (%rsi), %rsi
movq (%rdx), %rdi
cmpq (%rsi), %rdi
jne 0x70bd2
movl $0x1, %edi
movq %rdi, %rax
cmpq %rdi, %rcx
je 0x70bcc
movq (%rdx,%rax,8), %r8
leaq 0x1(%rax), %rdi
cmpq (%rsi,%rax,8), %r8
je 0x70bb6
cmpq %rcx, %rax
setae %al
popq %rcx
retq
callq 0x19bc4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_get_first_bitnum
GtUword gt_bittab_get_first_bitnum(const GtBittab *b)
{
  GtUword i, rval = GT_UNDEF_UWORD;
  gt_assert(b);
  for (i = 0; i < b->num_of_bits; i++)
    if (gt_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x70c37
movq %rdi, %rbx
movq $-0x1, %r14
cmpq $0x0, 0x10(%rdi)
je 0x70c24
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x70b1b
testb %al, %al
jne 0x70c21
incq %r15
cmpq 0x10(%rbx), %r15
jb 0x70c07
jmp 0x70c24
movq %r15, %r14
cmpq $-0x1, %r14
jne 0x70c2e
movq 0x10(%rbx), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x19c36
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_get_next_bitnum
GtUword gt_bittab_get_next_bitnum(const GtBittab *b,
                                        GtUword curnum)
{
  GtUword i, rval = GT_UNDEF_UWORD;

  gt_assert(b);
  gt_assert(curnum < b->num_of_bits);
  for (i = curnum + 1; i < b->num_of_bits; i++)
    if (gt_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x70c97
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x10(%rdi)
jbe 0x70c9c
incq %rbx
cmpq 0x10(%r14), %rbx
jae 0x70c7b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70b1b
testb %al, %al
je 0x70c61
jmp 0x70c82
movq $-0x1, %rbx
cmpq $-0x1, %rbx
jne 0x70c8c
movq 0x10(%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19ce1
callq 0x19ca8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bittab.c
// Function: gt_bittab_show
void gt_bittab_show(const GtBittab *b, FILE *outfp)
{
  GtUword i;
  gt_assert(b && outfp);
  /* header line */
  for (i = 0; i < b->num_of_bits; i++)
    fprintf(outfp, ""GT_WU"", i % 10);
  gt_xfputc('\n', outfp);
  /* actual bits */
  for (i = 0; i < b->num_of_bits; i++) {
    if (gt_bittab_bit_is_set(b, i))
      gt_xfputc('1', outfp);
    else
      gt_xfputc('0', outfp);
  }
  gt_xfputc('\n', outfp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x70dad
movq %rsi, %rbx
testq %rsi, %rsi
je 0x70dad
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x70d5e
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
leaq 0x7137f(%rip), %r15     # 0xe20ac
xorl %r12d, %r12d
movq %r12, %rax
mulq %r13
shrq $0x2, %rdx
andq $-0x2, %rdx
leaq (%rdx,%rdx,4), %rax
movq %r12, %rdx
subq %rax, %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb8d0
incq %r12
cmpq 0x10(%r14), %r12
jb 0x70d30
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3dc12
cmpq $0x0, 0x10(%r14)
je 0x70d97
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x70b1b
movzbl %al, %edi
orl $0x30, %edi
movq %rbx, %rsi
callq 0x3dc12
incq %r15
cmpq 0x10(%r14), %r15
jb 0x70d75
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3dc12
callq 0x19d53
// File: /workspace/github_c_makefile_star2_O1/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 0x70dc4
callq 0x3566a
testb %al, %al
jne 0x70e2f
movl $0x20, %edi
callq 0x70724
movq %rax, %rbx
movl $0x8, %esi
movq %rax, %rdi
callq 0x70790
movl $0x10, %esi
movq %rbx, %rdi
callq 0x70790
movl $0x18, %esi
movq %rbx, %rdi
callq 0x70790
movq %rbx, %rdi
callq 0x70be9
movq %rax, %r14
movq %rbx, %rdi
callq 0x70c3c
cmpq %rax, %r14
je 0x70e1d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x70c4c
jmp 0x70e00
movq %rbx, %rdi
callq 0x70e34
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19d8c
// File: /workspace/github_c_makefile_star2_O1/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, 0xe0efc(%rip)     # 0x152bb0
jne 0x71cc7
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0xe0ee9(%rip)     # 0x152bb0
leaq 0x7e3c2(%rip), %rdx     # 0xf0090
movl $0x1, %edi
movq %rbx, %rsi
movl $0x1d, %ecx
callq 0x3601f
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq 0xe0ec1(%rip), %rdi     # 0x152bb0
movl $0x8, %edx
movq %rbx, %rsi
callq 0x6ec0e
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0xe0ea3(%rip)     # 0x152bb0
je 0x71d7e
pushq %r14
pushq %rbx
pushq %rax
movq 0xe0e96(%rip), %rdi     # 0x152bb0
callq 0x6ecda
testq %rax, %rax
je 0x71d60
xorl %ebx, %ebx
leaq 0x7e363(%rip), %r14     # 0xf0090
movq 0xe0e7c(%rip), %rdi     # 0x152bb0
movq %rbx, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movq %r14, %rsi
movl $0x27, %edx
callq 0x362a0
incq %rbx
movq 0xe0e5a(%rip), %rdi     # 0x152bb0
callq 0x6ecda
cmpq %rax, %rbx
jb 0x71d2d
movq 0xe0e49(%rip), %rdi     # 0x152bb0
callq 0x6f134
movq $0x0, 0xe0e39(%rip) # 0x152bb0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/combinatorics.c
// Function: gt_combinatorics_init
static inline void init_ln_n_fac_tab(void)
{
  GtUword idx;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0xe0dec(%rip)     # 0x152bc0
jne 0x71e42
leaq 0x7e338(%rip), %rdx     # 0xf0115
movl $0x43, %edi
movl $0x8, %esi
movl $0x2c, %ecx
callq 0x3601f
movq %rax, 0xe0dc8(%rip)     # 0x152bc0
movq $0x0, (%rax)
movl $0x1, %ebx
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
callq 0xb4d0
movq 0xe0da8(%rip), %rax     # 0x152bc0
addsd -0x8(%rax,%rbx,8), %xmm0
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
cmpq $0x43, %rbx
jne 0x71e04
movsd 0x210(%rax), %xmm0
leaq 0x7e38b(%rip), %rdi     # 0xf01c6
movb $0x1, %al
callq 0x35a32
cmpq $0x0, 0xe0d7e(%rip)     # 0x152bc8
jne 0x71f1f
leaq 0x7e2be(%rip), %rbx     # 0xf0115
movl $0x220, %edi            # imm = 0x220
movq %rbx, %rsi
movl $0x3c, %edx
callq 0x35ee2
movq %rax, 0xe0d58(%rip)     # 0x152bc8
movl $0x4840, %edi           # imm = 0x4840
movq %rbx, %rsi
movl $0x3c, %edx
callq 0x35ee2
movq 0xe0d3f(%rip), %rbx     # 0x152bc8
movq %rax, (%rbx)
addq $0x110, %rax            # imm = 0x110
movl $0x1, %ecx
movq %rax, (%rbx,%rcx,8)
incq %rcx
addq $0x110, %rax            # imm = 0x110
cmpq $0x44, %rcx
jne 0x71e97
movq (%rbx), %rdi
addq $0x8, %rdi
xorl %r14d, %r14d
movl $0x108, %edx            # imm = 0x108
xorl %esi, %esi
callq 0xb2f0
movq (%rbx,%r14,8), %rax
movq $0x1, (%rax)
incq %r14
cmpq $0x44, %r14
jne 0x71ec0
movl $0x1, %eax
movl $0x1, %ecx
movl $0x1, %edx
cmpq %rcx, %rax
jbe 0x71f05
movq -0x8(%rbx,%rax,8), %rdx
movq -0x8(%rdx,%rcx,8), %rsi
movq (%rdx,%rcx,8), %rdx
testq %rdx, %rdx
je 0x71f02
addq %rsi, %rdx
jae 0x71f05
jmp 0x71f27
movq %rsi, %rdx
movq (%rbx,%rax,8), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq $0x22, %rcx
jne 0x71ede
incq %rax
cmpq $0x44, %rax
jne 0x71ed9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19e6c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/combinatorics.c
// Function: gt_combinatorics_clean
void gt_combinatorics_clean(void)
{
  gt_free(ln_n_fac_tab);
  ln_n_fac_tab = NULL;
  gt_array2dim_delete(binomial_dp_tab);
  binomial_dp_tab = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xe0c89(%rip), %rdi     # 0x152bc0
leaq 0x7e1d7(%rip), %rbx     # 0xf0115
movq %rbx, %rsi
movl $0x56, %edx
callq 0x362a0
xorl %r14d, %r14d
movq %r14, 0xe0c6b(%rip)     # 0x152bc0
movq 0xe0c6c(%rip), %rax     # 0x152bc8
movq (%rax), %rdi
movq %rbx, %rsi
movl $0x58, %edx
callq 0x362a0
movq 0xe0c55(%rip), %rdi     # 0x152bc8
movq %rbx, %rsi
movl $0x58, %edx
callq 0x362a0
movq %r14, 0xe0c41(%rip)     # 0x152bc8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x72008
cmpq $0x43, %rdi
jae 0x7200f
movq %rdi, %rcx
shrq %rcx
cmpq %rsi, %rcx
cmovaeq %rsi, %rax
movq 0xe0bf3(%rip), %rcx     # 0x152bc0
movsd (%rcx,%rdi,8), %xmm0
subsd (%rcx,%rax,8), %xmm0
subq %rax, %rdi
subsd (%rcx,%rdi,8), %xmm0
callq 0xbb70
callq 0x7a3a3
leaq 0x7e125(%rip), %rsi     # 0xf0115
leaq 0xcfe5(%rip), %rcx      # 0x7efdc
movq %rax, %rdi
movl $0x6d, %edx
xorl %r8d, %r8d
popq %rax
jmp 0x7f0e8
movl $0x1, %eax
popq %rcx
retq
callq 0x19e97
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/combinatorics.c
// Function: gt_combinatorics_binomial_simple
GtUword gt_combinatorics_binomial_simple(GtUword n, GtUword k)
{
  GtUword idx;
  GtUword result;
  if (n < k)
    return 0;
  if (k == 0 || k == n)
    return 1UL;
  gt_assert(n <= GT_BINOMIAL_MAX_N);
  if (GT_DIV2(n) < k)
    k = n - k;
  result = n - k + 1;
  for (idx = 2UL; idx <= k; idx++) {
#if defined (_LP64) || defined (_WIN64)
    result = (GtUword) gt_safe_mult_u64((uint64_t) result,
                                              (uint64_t) (n - k + idx));
#else
    result = (GtUword) gt_safe_mult_u32((uint32_t) result,
                                              (uint32_t) (n - k + idx));
#endif
    result /= idx;
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rsi, %rdi
jae 0x72026
xorl %eax, %eax
jmp 0x7209c
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
movq %rdi, %r12
subq %rsi, %r12
sete %cl
orb %al, %cl
movl $0x1, %eax
jne 0x7209c
cmpq $0x3f, %rbx
jae 0x720a6
movq %rbx, %rax
shrq %rax
cmpq %rsi, %rax
cmovaeq %rsi, %r12
subq %r12, %rbx
leaq 0x1(%rbx), %rax
cmpq $0x2, %r12
jb 0x7209c
movl $0x2, %r13d
leaq 0x7e0a7(%rip), %r14     # 0xf0115
leaq 0xcf67(%rip), %r15      # 0x7efdc
leaq (%rbx,%r13), %rsi
movq %rax, %rdi
movq %r14, %rdx
movl $0x7f, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x7f03d
xorl %edx, %edx
divq %r13
incq %r13
cmpq %r12, %r13
jbe 0x72075
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x19ece
// File: /workspace/github_c_makefile_star2_O1/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 0x720ce
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x721c4
xorl %eax, %eax
xorl %ebp, %ebp
movq %rbp, %r14
shrq %r14
incq %r14
xorl %r15d, %r15d
movl %eax, %r13d
movq 0xe0ae0(%rip), %rax     # 0x152bc8
movq (%rax,%rbp,8), %rax
movq (%rax,%r15,8), %r12
movq %rbp, %rdi
movq %r15, %rsi
callq 0x72014
movq %rax, %rcx
xorl %eax, %eax
testl %r13d, %r13d
je 0x7210a
xorl %r13d, %r13d
jmp 0x72141
movb $0x1, %r13b
cmpq %rcx, %r12
je 0x72146
xorl %r13d, %r13d
movq %rbx, %rdi
leaq 0x7105a(%rip), %rsi     # 0xe3179
leaq 0x7e092(%rip), %rdx     # 0xf01b8
leaq 0x7e070(%rip), %rcx     # 0xf019d
leaq 0x7dfe1(%rip), %r8      # 0xf0115
movl $0x95, %r9d
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x2e, %rbp
ja 0x7219c
movq %rbp, %rdi
movq %r15, %rsi
callq 0x71f9f
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %r13b, %r13b
je 0x7219c
xorl %eax, %eax
cmpq %r12, %rcx
je 0x7219c
movq %rbx, %rdi
leaq 0x71004(%rip), %rsi     # 0xe3179
leaq 0x7e043(%rip), %rdx     # 0xf01bf
leaq 0x7e01a(%rip), %rcx     # 0xf019d
leaq 0x7df8b(%rip), %r8      # 0xf0115
movl $0x98, %r9d
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incq %r15
cmpq %r15, %r14
jne 0x720de
incq %rbp
cmpq $0x3f, %rbp
jne 0x720d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19f05
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x722d2
movl %esi, %ebx
movq %rdi, %r14
callq 0xb260
testq %rax, %rax
je 0x72209
xorl %ecx, %ecx
xorl %edi, %edi
xorl %edx, %edx
cmpb %bl, (%r14,%rcx)
sete %dl
addq %rdx, %rdi
incq %rcx
cmpq %rcx, %rax
jne 0x721f3
jmp 0x7220b
xorl %edi, %edi
leaq 0x1(%rdi), %rax
movq %rax, (%rsp)
addq $0x2, %rdi
leaq 0x7dfe6(%rip), %rdx     # 0xf0204
movl $0x8, %esi
movl $0x28, %ecx
callq 0x3601f
movq %rax, %r15
movq %r14, %rdi
callq 0xb260
xorl %ebp, %ebp
cmpq $-0x1, %rax
je 0x722b2
xorl %r13d, %r13d
xorl %r12d, %r12d
movb (%r14,%r12), %al
cmpb %bl, %al
setne %cl
testb %al, %al
setne %al
testb %al, %cl
jne 0x7229f
testq %r12, %r12
je 0x72280
movq %r12, %rdi
subq %r13, %rdi
incq %rdi
movl $0x1, %esi
leaq 0x7df92(%rip), %rdx     # 0xf0204
movl $0x2c, %ecx
callq 0x3601f
movq %rax, (%r15,%rbp,8)
movq %r12, %rdx
subq %r13, %rdx
je 0x72297
movq (%r15,%rbp,8), %rdi
addq %r14, %r13
movq %r13, %rsi
callq 0xb520
leaq 0x1(%r12), %r13
incq %rbp
incq %r12
movq %r14, %rdi
callq 0xb260
incq %rax
cmpq %rax, %r12
jb 0x72246
cmpq (%rsp), %rbp
jne 0x722d7
movq $0x0, (%r15,%rbp,8)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19f75
callq 0x19f3e
// File: /workspace/github_c_makefile_star2_O1/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 0x7231a
movq %rdi, %rbx
callq 0xb260
leaq 0x1(%rax), %r14
leaq 0x7df0c(%rip), %rsi     # 0xf0204
movq %r14, %rdi
movl $0x3e, %edx
callq 0x35ee2
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb520
callq 0x19fac
// File: /workspace/github_c_makefile_star2_O1/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 0x72363
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
leaq 0x7deca(%rip), %rsi     # 0xf0204
movl $0x47, %edx
callq 0x35ee2
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb520
movb $0x0, (%r15,%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x19fe3